From 8a672c2aa2298a0d9886d69bb6bd75c8fed29878 Mon Sep 17 00:00:00 2001 From: Dylan Roy <249851642+d6g8k5htny-coder@users.noreply.github.com> Date: Tue, 20 Oct 2026 10:15:29 -0500 Subject: [PATCH] test(formal-regression): freeze controls and isolated hosted caller Add reviewed R01 contracts, synthetic fixtures, scaffold and R02 hosted controls workflow. Core functions remain unimplemented; no qualified RED/GREEN, native custody or formal/scientific acceptance is claimed. --- .../workflows/formal-regression-controls.yml | 1750 ++++ architecture/formal_regression.py | 33 + .../formal-regression-contract.json | 563 ++ ...mal-regression-collector-implementation.md | 191 + ...0-18-formal-regression-collector-design.md | 126 + .../formal_regression/control-plan.json | 7226 +++++++++++++++++ .../inventory-conformance.json | 1376 ++++ tests/test_formal_regression.py | 1100 +++ 8 files changed, 12365 insertions(+) create mode 100644 .github/workflows/formal-regression-controls.yml create mode 100644 architecture/formal_regression.py create mode 100644 docs/architecture/formal-regression-contract.json create mode 100644 docs/superpowers/plans/2026-10-18-formal-regression-collector-implementation.md create mode 100644 docs/superpowers/specs/2026-10-18-formal-regression-collector-design.md create mode 100644 tests/fixtures/formal_regression/control-plan.json create mode 100644 tests/fixtures/formal_regression/inventory-conformance.json create mode 100644 tests/test_formal_regression.py diff --git a/.github/workflows/formal-regression-controls.yml b/.github/workflows/formal-regression-controls.yml new file mode 100644 index 000000000..f8dc6ea1d --- /dev/null +++ b/.github/workflows/formal-regression-controls.yml @@ -0,0 +1,1750 @@ +name: Formal regression frozen controls +# R01 private source candidate; hosted behavior and admission remain NOT_RUN. +# V1 is preserved. Shared retained-evidence limits and unresolved event custody are explicit. +# Dedicated observation lane. Existing generic graph/export/required checks remain unchanged. +'on': + pull_request: + branches: [main] + types: [opened, synchronize, reopened, ready_for_review] +permissions: + contents: read +concurrency: + group: formal-regression-controls-${{ github.run_id }}-${{ github.run_attempt }} + cancel-in-progress: false +jobs: + controls: + name: formal-regression-controls + runs-on: ubuntu-24.04 + timeout-minutes: 49 + env: + FORMAL_EVIDENCE_TEMP: ${{ runner.temp }}/formal-retained-volume-${{ github.run_id }}-${{ github.run_attempt }}/mount + defaults: + run: + shell: bash + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + timeout-minutes: 1 + with: + persist-credentials: false + fetch-depth: 0 + - name: Parse dedicated and canonical workflows without executing source + timeout-minutes: 1 + run: | + set -euo pipefail + ruby -rpsych -e 'ARGV.each { |p| Psych.safe_load(File.read(p), aliases: false) }' .github/workflows/formal-regression-controls.yml .github/workflows/architecture-runtime-acquisition.yml + - name: Create only the owned bounded retained-evidence filesystem + timeout-minutes: 2 + run: | + set -euo pipefail + python3 -I -B -S - <<'PY' + import hashlib,json,os,pathlib,re,selectors,signal,stat,subprocess,time + native={key:os.environ[name] for key,name in (('repository','GITHUB_REPOSITORY'),('checked_commit','GITHUB_SHA'),('run_id','GITHUB_RUN_ID'),('run_attempt','GITHUB_RUN_ATTEMPT'))} + root=pathlib.Path(os.environ['RUNNER_TEMP'])/('formal-retained-volume-'+native['run_id']+'-'+native['run_attempt']);root.mkdir(mode=0o700,exist_ok=False) + with (root/'storage-native-context.json').open('xb') as stream:stream.write((json.dumps({'schema_version':1,'native_context':native},sort_keys=True)+'\n').encode()) + mount=root/'mount';mount.mkdir(mode=0o700,exist_ok=False) + records=[] + def command(argv): + proc=None;sel=selectors.DefaultSelector();buffers={'stdout':bytearray(),'stderr':bytearray()};record={'argv':argv,'complete':False,'exit_code':None,'process_unreaped':False,'error':None};end=time.monotonic()+30 + try: + proc=subprocess.Popen(argv,stdin=subprocess.DEVNULL,stdout=subprocess.PIPE,stderr=subprocess.PIPE,start_new_session=True, + env={'PATH':'/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin','LANG':'C.UTF-8','TZ':'UTC'}) + for stream,name in ((proc.stdout,'stdout'),(proc.stderr,'stderr')):os.set_blocking(stream.fileno(),False);sel.register(stream,selectors.EVENT_READ,name) + while sel.get_map(): + if time.monotonic()>=end:raise TimeoutError('bounded owned storage operation') + for key,_ in sel.select(min(0.2,max(0,end-time.monotonic()))): + part=os.read(key.fileobj.fileno(),65536) + if not part:sel.unregister(key.fileobj);key.fileobj.close();continue + room=65536-len(buffers[key.data]);buffers[key.data].extend(part[:room]) + if len(part)>room:raise ValueError('owned storage original stream limit') + record['exit_code']=proc.wait(timeout=max(0.01,end-time.monotonic()));record['complete']=True + except BaseException as exc:record['error']=type(exc).__name__ + finally: + if proc is not None and proc.poll() is None: + for sig,grace in ((signal.SIGTERM,4),(signal.SIGKILL,1)): + if proc.poll() is not None:break + try:os.killpg(proc.pid,sig);proc.wait(timeout=grace) + except (ProcessLookupError,subprocess.TimeoutExpired):pass + record['process_unreaped']=proc.poll() is None + if proc is not None: + record['exit_code']=proc.returncode + for stream in (proc.stdout,proc.stderr): + if stream is not None and not stream.closed:stream.close() + sel.close();record.update({k:bytes(v).decode('utf-8','backslashreplace') for k,v in buffers.items()});records.append(record) + metadata=(json.dumps({'schema_version':1,'native_context':native,'records':records,'qualification':'HOST_OBSERVATIONS_ONLY; RETAIN_AND_REVIEW'},sort_keys=True)+'\n').encode() + if len(metadata)>900000:raise ValueError('bootstrap metadata reserve exhausted') + with (root/'storage-bootstrap.json').open('wb') as stream:stream.write(metadata) + if not record['complete'] or record['process_unreaped'] or record['exit_code']!=0:raise ValueError('owned bounded storage setup incomplete') + return bytes(buffers['stdout']) + image=root/'retained.img' + command(['truncate','-s','63M',str(image)]);command(['mkfs.ext4','-F',str(image)]) + command(['sudo','-n','mount','-o','loop,nodev,nosuid,noexec',str(image),str(mount)]) + command(['sudo','-n','chown',str(os.getuid())+':'+str(os.getgid()),str(mount)]);mount.chmod(0o700) + capacity=os.statvfs(mount);total=capacity.f_frsize*capacity.f_blocks + if not 02**20:raise ValueError('owned storage bootstrap metadata bound') + with (mount/'storage-bootstrap.json').open('xb') as stream:stream.write(raw) + with (mount/'storage-capacity.json').open('xb') as stream:stream.write((json.dumps({'schema_version':1,'native_context':native,'physical_capacity_bytes':total,'device_limit_bytes':63*2**20,'outside_bootstrap_fallback_limit_bytes':2**20,'combined_owned_transient_storage_limit_bytes':64*2**20,'emergency_reserved_bytes':7*2**20,'worker_output_device_separate':True,'actual_fit':'UNKNOWN'},sort_keys=True)+'\n').encode()) + PY + - name: Reserve the single bounded retained-evidence budget before preparation + timeout-minutes: 1 + run: | + set -euo pipefail + python3 -I -B -S - <<'PY' + import json,os,pathlib,re + native={key:os.environ[name] for key,name in (('repository','GITHUB_REPOSITORY'),('checked_commit','GITHUB_SHA'),('run_id','GITHUB_RUN_ID'),('run_attempt','GITHUB_RUN_ATTEMPT'))} + if not re.fullmatch('[0-9a-f]{40}',native['checked_commit']) or not all(re.fullmatch('[1-9][0-9]*',native[k]) for k in ('run_id','run_attempt')): + raise ValueError('native global-budget context unavailable') + root=pathlib.Path(os.environ['FORMAL_EVIDENCE_TEMP'])/('formal-regression-budget-'+native['run_id']+'-'+native['run_attempt']) + root.mkdir(mode=0o700,exist_ok=False) + policy={'schema_version':1,'native_context':native,'total_retained_decompressed_bytes':64*2**20,'total_members':1024, + 'metadata_response_bytes':4*2**20,'transient_evidence_physical_bytes':64*2**20,'owned_retained_device_bytes':63*2**20,'outside_bootstrap_fallback_bytes':2**20,'raw_native_archives_reserved_bytes':4*2**20,'native_job_log_reserved_bytes':4*2**20,'native_transport_reserved_members':8,'preparation_reserved_bytes':36*2**20,'preparation_reserved_members':256, + 'ordinary_control_ceiling_bytes':32*2**20,'recovery_reserved_bytes':2*2**20,'recovery_reserved_members':32, + 'final_seal_reserved_bytes':7*2**20,'final_seal_reserved_members':32,'native_archive_overhead_reserved_bytes':2**20,'worker_output_device_bytes':64*2**20, + 'unit':'SUM_OF_EACH_RETAINED_NATIVE_ARCHIVE_MEMBER_BYTES; EACH_DISTINCT_ARCHIVE_MEMBER_COPY_COUNTS; NO_CONTENT_DEDUPLICATION', + 'same_member_staging_replicas':'One eventual member represented in OUT and publish is joined byte-exactly, not counted as two native-archive members; distinct names/copies always count', + 'archive_raw_byte_fit':'UNKNOWN_REQUIRES_NATIVE_ARCHIVE_READBACK; NO_COMPLETENESS_OR_POSITIVE_FIT_CLAIM'} + raw=(json.dumps(policy,sort_keys=True)+'\n').encode() + fd=os.open(root/'policy.json',os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,0o400) + with os.fdopen(fd,'wb') as stream:stream.write(raw);stream.flush();os.fsync(stream.fileno()) + PY + - name: Extract whole-pinned qualified preparation sources + timeout-minutes: 1 + run: | + set -euo pipefail + python3 -I -B -S - "$FORMAL_EVIDENCE_TEMP" "$GITHUB_WORKSPACE" "$GITHUB_RUN_ID" "$GITHUB_RUN_ATTEMPT" <<'PY' + import hashlib, json, os, pathlib, stat, sys + def require(value, message): + if not value: + raise ValueError(message) + def original(path, size, digest): + path = pathlib.Path(path) + require(path.is_absolute(), 'absolute admitted path required') + parent = os.open(path.anchor, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW) + try: + for part in path.parts[1:-1]: + child = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW, dir_fd=parent) + os.close(parent) + parent = child + descriptor = os.open(path.name, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK, dir_fd=parent) + finally: + os.close(parent) + try: + before = os.fstat(descriptor) + require(stat.S_ISREG(before.st_mode) and before.st_nlink == 1 and before.st_size == size, + 'qualified whole-source size/type mismatch') + raw = b'' + while len(raw) <= size: + part = os.read(descriptor, min(65536, size + 1 - len(raw))) + if not part: + break + raw += part + after = os.fstat(descriptor) + require((before.st_dev, before.st_ino, before.st_size, before.st_mtime_ns, before.st_ctime_ns) + == (after.st_dev, after.st_ino, after.st_size, after.st_mtime_ns, after.st_ctime_ns) + and len(raw) == size and hashlib.sha256(raw).hexdigest() == digest, + 'qualified whole-source changed or pin mismatch') + return raw + finally: + os.close(descriptor) + temporary, workspace = map(pathlib.Path, sys.argv[1:3]) + run_id, attempt = sys.argv[3:5] + require(run_id.isdecimal() and attempt.isdecimal(), 'native preparation path context') + workflow = original(workspace / '.github/workflows/architecture-runtime-acquisition.yml', 95714, + '9b33eee757bae53966a151150bc62bc6aec13f9aa8226b4398dfa3362597de65') + original(workspace / 'docs/plans/2026-10-09-public-runtime-acquisition.md', 22516, + '72bdcf2b2374216f415fb6d86b84c2db25e7855caf0699bdfe2473336fb64bb7') + destination = temporary / ('formal-regression-preparation-source-' + run_id + '-' + attempt) + destination.mkdir(mode=0o700, exist_ok=False) + lines = workflow.decode('ascii').splitlines() + selection = ( + ('write-sources.sh', 'Write fixed trusted preparation sources'), + ('run-preparation.sh', 'Parse the standalone source and run the preparation once'), + ('seal.sh', 'Seal available originals on every conclusion'), + ('cleanup.sh', 'Remove only owned preparation client and control files')) + for filename, name in selection: + starts = [index for index, line in enumerate(lines) if line == ' - name: ' + name] + require(len(starts) == 1, 'ambiguous qualified step marker') + start = starts[0] + end = next((index for index in range(start + 1, len(lines)) + if lines[index].startswith(' - ')), len(lines)) + block = lines[start:end] + markers = [index for index, line in enumerate(block) if line == ' run: |'] + require(len(markers) == 1, 'ambiguous qualified literal run source') + body = block[markers[0] + 1:] + require(body and all(line.startswith(' ') for line in body), + 'qualified literal script indentation') + raw = ('\n'.join(line[10:] for line in body) + '\n').encode('ascii') + descriptor = os.open(destination / filename, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, 0o444) + with os.fdopen(descriptor, 'wb') as stream: + stream.write(raw) + print(json.dumps({'qualified_sources': 'PIN_MATCH', 'literal_scripts': len(selection)})) + PY + RUNNER_TEMP="$FORMAL_EVIDENCE_TEMP" bash "$FORMAL_EVIDENCE_TEMP/formal-regression-preparation-source-$GITHUB_RUN_ID-$GITHUB_RUN_ATTEMPT/write-sources.sh" + - name: Qualify canonical acquisition and restore daemon before tests + id: preparation + timeout-minutes: 19 + run: | + set -euo pipefail + RUNNER_TEMP="$FORMAL_EVIDENCE_TEMP" bash "$FORMAL_EVIDENCE_TEMP/formal-regression-preparation-source-$GITHUB_RUN_ID-$GITHUB_RUN_ATTEMPT/run-preparation.sh" + - name: Seal separate preparation originals on every conclusion + id: preparation_seal + if: always() + timeout-minutes: 1 + run: | + set -euo pipefail + RUNNER_TEMP="$FORMAL_EVIDENCE_TEMP" bash "$FORMAL_EVIDENCE_TEMP/formal-regression-preparation-source-$GITHUB_RUN_ID-$GITHUB_RUN_ATTEMPT/seal.sh" + - name: Account every preparation member before its native upload + id: preparation_budget + if: always() + timeout-minutes: 1 + run: | + set -euo pipefail + python3 -I -B -S - <<'PY' + import hashlib,json,os,pathlib,re,stat + MIB=2**20 + def require(value,message): + if not value:raise ValueError(message) + def read(path,limit): + path=pathlib.Path(path);parent=os.open(path.anchor,os.O_RDONLY|os.O_DIRECTORY|os.O_NOFOLLOW);leaf=None + try: + for part in path.parts[1:-1]: + child=os.open(part,os.O_RDONLY|os.O_DIRECTORY|os.O_NOFOLLOW,dir_fd=parent);os.close(parent);parent=child + leaf=os.open(path.name,os.O_RDONLY|os.O_NOFOLLOW|os.O_NONBLOCK,dir_fd=parent);before=os.fstat(leaf) + require(stat.S_ISREG(before.st_mode) and before.st_nlink==1 and before.st_size<=limit,'bounded preparation member') + raw=b'' + while len(raw)<=limit: + part=os.read(leaf,min(65536,limit+1-len(raw))) + if not part:break + raw+=part + after=os.fstat(leaf);require((before.st_dev,before.st_ino,before.st_size,before.st_mtime_ns,before.st_ctime_ns)==(after.st_dev,after.st_ino,after.st_size,after.st_mtime_ns,after.st_ctime_ns) and len(raw)==before.st_size,'preparation member changed') + return raw + finally: + if leaf is not None:os.close(leaf) + os.close(parent) + native={key:os.environ[name] for key,name in (('repository','GITHUB_REPOSITORY'),('checked_commit','GITHUB_SHA'),('run_id','GITHUB_RUN_ID'),('run_attempt','GITHUB_RUN_ATTEMPT'))} + temporary=pathlib.Path(os.environ['FORMAL_EVIDENCE_TEMP']);budget=temporary/('formal-regression-budget-'+native['run_id']+'-'+native['run_attempt']) + policy_raw=read(budget/'policy.json',65536);policy=json.loads(policy_raw) + require(policy['native_context']==native and policy['total_retained_decompressed_bytes']==64*MIB and policy['total_members']==1024,'one current-run global policy') + source=temporary/('public-runtime-'+native['run_id']+'-'+native['run_attempt'])/'publish' + fallback=budget/'preparation-fallback';fallback.mkdir(mode=0o700,exist_ok=False) + members=[];errors=[];total=0 + try: + info=source.lstat();require(stat.S_ISDIR(info.st_mode) and info.st_uid==os.getuid() and stat.S_IMODE(info.st_mode)==0o700,'owned preparation directory') + entries=sorted(source.iterdir(),key=lambda p:p.name);require(len(entries)<=256,'preparation member reservation') + for path in entries: + require(re.fullmatch(r'[A-Za-z0-9_.-]+',path.name),'closed preparation member name') + # Each stream/source/receipt/manifest copy is counted, including equal bytes under different names. + raw=read(path,4*MIB);total+=len(raw);require(total<=36*MIB,'preparation bytes exceed shared reservation') + members.append({'path':path.name,'bytes':len(raw),'sha256':hashlib.sha256(raw).hexdigest()}) + require(members,'preparation originals absent') + except BaseException as exc:errors.append({'type':type(exc).__name__,'reason':'PREPARATION_SHARED_BUDGET_OR_MEMBER_ADMISSION_FAILED'}) + record={'schema_version':1,'native_context':native,'policy_sha256':hashlib.sha256(policy_raw).hexdigest(),'status':'BOUNDED_PREPARATION_MEMBERS' if not errors else 'HOLD','members':members,'original_bytes':total,'original_count':len(members),'errors':errors, + 'preparation_complete_or_qualified':False,'raw_archive_fit':'UNKNOWN','actual_private_custody':'UNKNOWN'} + if errors: + raw=(json.dumps({'schema_version':1,'native_context':native,'status':'HOLD','reason':'PREPARATION_ORIGINALS_UNAVAILABLE_OR_OUTSIDE_SHARED_BOUNDS','originals_complete':False,'errors':errors},sort_keys=True)+'\n').encode() + with (fallback/'preparation-hold.json').open('xb') as stream:stream.write(raw) + record.update(members=[{'path':'preparation-hold.json','bytes':len(raw),'sha256':hashlib.sha256(raw).hexdigest()}],original_bytes=len(raw),original_count=1,artifact_path_kind='BOUNDED_HOLD_ONLY') + upload=fallback + else:upload=source;record['artifact_path_kind']='ORIGINAL_CANONICAL_PREPARATION' + raw=(json.dumps(record,sort_keys=True)+'\n').encode();require(len(raw)<=MIB,'preparation budget record bound') + fd=os.open(budget/'preparation-account.json',os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,0o400) + with os.fdopen(fd,'wb') as stream:stream.write(raw);stream.flush();os.fsync(stream.fileno()) + with open(os.environ['GITHUB_OUTPUT'],'a') as stream:stream.write('upload_path='+str(upload)+'\n') + PY + - name: Retain separate bounded preparation originals + id: preparation_retained + if: always() + timeout-minutes: 1 + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 + with: + name: formal-regression-preparation-${{ github.run_id }}-${{ github.run_attempt }} + path: ${{ steps.preparation_budget.outputs.upload_path }} + if-no-files-found: error + retention-days: 90 + compression-level: 6 + - name: Remove only owned preparation and extraction files + id: preparation_cleanup + if: always() + timeout-minutes: 1 + run: | + set -euo pipefail + directory="$FORMAL_EVIDENCE_TEMP/formal-regression-preparation-source-$GITHUB_RUN_ID-$GITHUB_RUN_ATTEMPT" + RUNNER_TEMP="$FORMAL_EVIDENCE_TEMP" bash "$directory/cleanup.sh" + python3 -I -B -S - "$directory" <<'PY' + import os, pathlib, stat, sys + directory = pathlib.Path(sys.argv[1]) + info = directory.lstat() + if not stat.S_ISDIR(info.st_mode) or info.st_uid != os.getuid() or stat.S_IMODE(info.st_mode) != 0o700: + raise ValueError('owned extraction directory identity') + names = {'write-sources.sh', 'run-preparation.sh', 'seal.sh', 'cleanup.sh'} + if {path.name for path in directory.iterdir()} != names: + raise ValueError('closed owned extraction inventory') + for name in sorted(names): + path = directory / name + info = path.lstat() + if not stat.S_ISREG(info.st_mode) or info.st_nlink != 1 or info.st_uid != os.getuid() or info.st_size > 1024 * 1024: + raise ValueError('owned extraction file identity/bound') + path.unlink() + directory.rmdir() + PY + - name: Require complete current-run preparation before formal controls + timeout-minutes: 1 + env: + PREPARATION_ARTIFACT_ID: ${{ steps.preparation_retained.outputs.artifact-id }} + PREPARATION_ARTIFACT_DIGEST: ${{ steps.preparation_retained.outputs.artifact-digest }} + run: | + set -euo pipefail + python3 -I -B -S - "$FORMAL_EVIDENCE_TEMP/public-runtime-$GITHUB_RUN_ID-$GITHUB_RUN_ATTEMPT/publish" <<'PY' + import hashlib, json, math, os, pathlib, re, stat, sys + MIB = 2**20 + def require(value, message): + if not value: + raise ValueError(message) + def read(path, limit): + path = pathlib.Path(path) + require(path.is_absolute(), 'absolute admitted path required') + parent = os.open(path.anchor, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW) + try: + for part in path.parts[1:-1]: + child = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW, dir_fd=parent) + os.close(parent) + parent = child + descriptor = os.open(path.name, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK, dir_fd=parent) + finally: + os.close(parent) + try: + before = os.fstat(descriptor) + require(stat.S_ISREG(before.st_mode) and before.st_nlink == 1 and before.st_size <= limit, + 'sealed preparation regular-file admission') + raw = b'' + while len(raw) <= limit: + part = os.read(descriptor, min(65536, limit + 1 - len(raw))) + if not part: + break + raw += part + after = os.fstat(descriptor) + require((before.st_dev, before.st_ino, before.st_size, before.st_mtime_ns, before.st_ctime_ns) + == (after.st_dev, after.st_ino, after.st_size, after.st_mtime_ns, after.st_ctime_ns) + and len(raw) == before.st_size <= limit, 'sealed preparation changed during read') + return raw + finally: + os.close(descriptor) + def strict(raw): + def pairs(items): + value = {} + for key, item in items: + require(key not in value, 'duplicate original JSON key') + value[key] = item + return value + def reject(value): + raise ValueError('nonfinite original JSON value') + def finite(value): + number=float(value) + require(math.isfinite(number), 'nonfinite JSON number') + return number + return json.loads(raw, object_pairs_hook=pairs, parse_constant=reject, parse_float=finite) + root = pathlib.Path(sys.argv[1]) + info = root.lstat() + require(stat.S_ISDIR(info.st_mode) and info.st_uid == os.getuid() + and stat.S_IMODE(info.st_mode) == 0o700, 'owned sealed preparation directory') + native = {key: os.environ[name] for key, name in ( + ('repository', 'GITHUB_REPOSITORY'), ('checked_commit', 'GITHUB_SHA'), + ('run_id', 'GITHUB_RUN_ID'), ('run_attempt', 'GITHUB_RUN_ATTEMPT'))} + require(re.fullmatch(r'[1-9][0-9]*', os.environ['PREPARATION_ARTIFACT_ID']) + and re.fullmatch(r'(?:sha256:)?[0-9a-f]{64}', os.environ['PREPARATION_ARTIFACT_DIGEST']), + 'native preparation upload identity unavailable') + manifest = {} + manifest_raw = read(root / 'ARTIFACT_SHA256SUMS', MIB) + for line in manifest_raw.decode('ascii').splitlines(): + match = re.fullmatch(r'([0-9a-f]{64}) ([A-Za-z0-9_.-]+)', line) + require(match is not None and match[2] not in manifest, 'closed preparation hash manifest') + manifest[match[2]] = match[1] + require(0 < len(manifest) <= 256 + and {path.name for path in root.iterdir()} == set(manifest) | {'ARTIFACT_SHA256SUMS'}, + 'exact sealed preparation inventory') + bodies, records, total = {}, {}, len(manifest_raw) + for name, digest in manifest.items(): + limit = 4 * MIB if name in ('pull.stdout', 'pull.stderr') else MIB + raw = read(root / name, limit) + total += len(raw) + require(total <= 36 * MIB and hashlib.sha256(raw).hexdigest() == digest, + 'sealed preparation original hash/aggregate bound') + bodies[name] = raw + records[name] = {'bytes': len(raw), 'sha256': digest} + receipt = strict(bodies['receipt.json']) + collection = strict(bodies['collection.json']) + result = strict(bodies['preparation-result.json']) + observation = strict(bodies['preparation-observations.json']) + semantic = strict(bodies['semantic-controls.json']) + for record in (receipt, collection): + require(record['status'] == 'ACCEPTED_PREPARATION' and record['native_context'] == native, + 'current-run sealed preparation acceptance required') + require(result['status'] == 'ACCEPTED_PREPARATION' and result['context'] == native + and observation['context'] == native and observation['head'] == native['checked_commit'] + and collection['missing'] == [] and collection['refused'] == [] + and result['preparation_error'] is None and result['recovery_error'] is None + and result['refused_originals'] == [], 'complete current-run preparation required') + rows = receipt['originals'] + joined = {row['path']: {'bytes': row['bytes'], 'sha256': row['sha256']} for row in rows} + require(len(joined) == len(rows) == receipt['original_count'] + and set(joined) == set(records) - {'receipt.json'} + and all(records[name] == record for name, record in joined.items()) + and receipt['original_bytes'] == sum(record['bytes'] for record in joined.values()), + 'receipt original copies/subtotal join') + copied = collection['copied'] + copies = {row['path']: {'bytes': row['bytes'], 'sha256': row['sha256']} for row in copied} + require(len(copies) == len(copied) and set(copies) == set(joined) - {'collection.json'} + and all(records[name] == record for name, record in copies.items()) + and set(copies) == set(result['available_originals']) | {'preparation-result.json'} + and all(copies[name] == record for name, record in result['available_originals'].items()), + 'collection/controller original copies join') + require(records['checked-workflow.yml'] == {'bytes': 95714, 'sha256': + '9b33eee757bae53966a151150bc62bc6aec13f9aa8226b4398dfa3362597de65'} + and records['contract.md'] == {'bytes': 22516, 'sha256': + '72bdcf2b2374216f415fb6d86b84c2db25e7855caf0699bdfe2473336fb64bb7'} + and observation['source_before'] == observation['source_after'], + 'qualified preparation whole sources stable') + negative_ids = ( + 'RP01_stale_run', 'RP01_changed_source', 'RP02_existing_container', 'RP02_cached_image', + 'RP03_missing_actual_mirror', 'RP03_changed_preserved_setting', 'RP04_manifest_substitution', + 'RP04_config_substitution', 'RP05_pull_nonzero', 'RP05_pull_incomplete', + 'RP06_mirror_prefixed_digest', 'RP06_extra_digest', 'RP06_wrong_image_platform', + 'RP07_native_root', 'RP07_missing_OO', 'RP08_wrong_sqlite_all_modes', 'RP08_wrong_OO_flag', + 'RP08_empty_binary_all_modes', 'RP09_wrong_CPU_all_modes', 'RP10_disposal_unconfirmed', + 'RP11_restored_mirror_wrong', 'RP11_restored_bytes_wrong', 'RP12_missing_original', + 'RP03_nested_synthetic_credential', 'RP09_oversized_overlay_lowerdir') + expected = [{'id': 'RP_positive_actual_copy', 'status': 'PASS'}] + expected += [{'id': name, 'status': 'REFUSED'} for name in negative_ids] + require(result['controls'] == semantic['controls'] == expected + and semantic['origin'] == 'TEST_SEMANTIC_MUTATIONS_OF_COPIED_ACTUAL_OBSERVATIONS', + 'all qualified actual-copy controls required') + require(observation['recovery_complete'] is True + and observation['containers_recovery_empty'] is True + and observation['containers_restored_empty'] is True + and observation['restored_mirrors'] == observation['original_mirrors'] + and set(observation['probes']) == {'0', '1', '2'} + and all(item['disposed'] is True for item in observation['probes'].values()) + and result['disposal_confirmed'] == {'0': True, '1': True, '2': True}, + 'owned probe disposal and daemon recovery before formal controls') + binding = {'schema_version': 1, 'native_context': native, + 'preparation_artifact_id': os.environ['PREPARATION_ARTIFACT_ID'], + 'preparation_artifact_digest': os.environ['PREPARATION_ARTIFACT_DIGEST'], + 'originals': records, 'whole_manifest_sha256': hashlib.sha256(manifest_raw).hexdigest(), + 'image': observation['image'], 'docker_version': observation['docker_version'], + 'probes': {mode: {'container_id': item['before']['Id'], 'disposed': item['disposed'], + 'binaries': item['probe']['binaries'], 'python_version': item['probe']['python_version'], + 'sqlite_version': item['probe']['sqlite_version']} for mode, item in observation['probes'].items()}, + 'daemon_recovery_complete': True, 'raw_archive_readback': 'REQUIRED_AFTER_JOB'} + target = pathlib.Path(os.environ['FORMAL_EVIDENCE_TEMP']) / ('formal-regression-preparation-binding-' + native['run_id'] + '-' + native['run_attempt'] + '.json') + descriptor = os.open(target, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, 0o400) + with os.fdopen(descriptor, 'wb') as stream: + stream.write((json.dumps(binding, sort_keys=True, allow_nan=False) + '\n').encode()) + print(json.dumps({'status': 'ACCEPTED_PREPARATION', 'current_run': native['run_id'], + 'positive': 'PASS', 'negative_refusals': len(negative_ids)})) + PY + - name: Write fixed trusted driver and host controller + timeout-minutes: 1 + run: | + set -euo pipefail + base="$FORMAL_EVIDENCE_TEMP/formal-regression-$GITHUB_RUN_ID-$GITHUB_RUN_ATTEMPT" + mkdir -m 0700 "$base" "$base/control" "$base/source" "$base/originals" "$base/publish" "$base/client" "$base/output" + cat > "$base/control/driver.py" <<'PY' + # Trusted recording driver; candidate imports occur only in the restricted worker. + import contextlib, hashlib, json, math, os, pathlib, resource, stat, sys, time, traceback, unittest + def require(value, message): + if not value: + raise ValueError(message) + mode = int(sys.argv[1]) + require(mode in (0, 1) and sys.flags.optimize == mode, 'actual interpreter mode') + require(sys.flags.isolated == 1 and sys.flags.no_site == 1 and sys.flags.dont_write_bytecode, + 'isolated fixed interpreter flags') + os.umask(0o077) + root, output = pathlib.Path('/source'), pathlib.Path('/output') + def strict(raw): + def pairs(items): + result = {} + for key, value in items: + require(key not in result, 'duplicate input key') + result[key] = value + return result + def reject(value): + raise ValueError('nonfinite input') + def finite(value): + number=float(value) + require(math.isfinite(number), 'nonfinite JSON number') + return number + return json.loads(raw, object_pairs_hook=pairs, parse_constant=reject, parse_float=finite) + plan = strict((root / 'tests/fixtures/formal_regression/control-plan.json').read_bytes()) + expected = plan['test_ids'] + flags = {'isolated': sys.flags.isolated, 'no_site': sys.flags.no_site, + 'dont_write_bytecode': sys.flags.dont_write_bytecode, 'optimize': sys.flags.optimize} + kernel = {'uid': os.getuid(), 'gid': os.getgid(), 'groups': os.getgroups(), + 'proc_status': {k: v.strip() for k, v in (line.split(':', 1) for line in + pathlib.Path('/proc/self/status').read_text().splitlines() if line.startswith(('CapEff:', 'NoNewPrivs:')))}, + 'cgroup': {k: pathlib.Path('/sys/fs/cgroup', k).read_text().strip() for k in ('cpu.max', 'memory.max', 'pids.max')}, + 'network_interfaces': sorted(os.listdir('/sys/class/net')), + 'network_routes': pathlib.Path('/proc/net/route').read_text().splitlines(), + 'tmpfs_bytes': os.statvfs('/tmp').f_frsize * os.statvfs('/tmp').f_blocks, + 'environment_names': sorted(os.environ), 'flags': flags, 'version': list(sys.version_info[:3]), + 'mountinfo': pathlib.Path('/proc/self/mountinfo').read_text(), + 'limits': {k: list(resource.getrlimit(v)) for k, v in ( + ('fsize', resource.RLIMIT_FSIZE), ('nofile', resource.RLIMIT_NOFILE), ('msgqueue', resource.RLIMIT_MSGQUEUE))}} + require(len(kernel['mountinfo'].encode()) <= 65536, 'worker mountinfo bound') + class BoundedText: + def __init__(self, path): + self.stream = path.open('xb'); os.fchmod(self.stream.fileno(), 0o644); self.size = 0 + def write(self, value): + raw = value.encode('utf-8', 'backslashreplace') + require(self.size + len(raw) <= 131072, 'per-method raw stream exceeded 128 KiB') + self.stream.write(raw); self.size += len(raw) + return len(value) + def flush(self): self.stream.flush() + def close(self): self.stream.close() + SUBTEST_AUDIT_CONTRACT = {'schema_version':1,'scope_order':'OUTER_TO_INNER','events':'UNMODIFIED_STDLIB_SUBTEST_CALLBACKS','event_bytes':8192,'method_events':256,'mode_events':2048,'mode_metadata_bytes':131072,'value_depth':8,'value_nodes':256,'scope_parameters':16,'scopes':8,'container_items':64,'key_bytes':128,'string_bytes':2048,'integer_characters':128} + # No generic repr/str fallback; unsupported metadata yields explicit incomplete evidence. + def audit_encode(value): + return (json.dumps(value,sort_keys=True,allow_nan=False)+'\n').encode() + def audit_value(value,depth,nodes): + nodes[0]+=1;require(depth<=8 and nodes[0]<=256,'nested value depth/node bound');kind=type(value) + if value is None:return {'type':'none'} + if kind is bool:return {'type':'bool','value':value} + if kind is int: + text=str(value);require(len(text)<=128,'nested integer bound');return {'type':'int','value':text} + if kind is float: + require(math.isfinite(value),'nested finite float');return {'type':'float','value':value.hex()} + if kind is str: + require(len(value.encode('utf-8'))<=2048,'nested string bound');return {'type':'str','value':value} + if kind in (list,tuple): + require(len(value)<=64,'nested sequence bound');return {'type':'list' if kind is list else 'tuple','items':[audit_value(v,depth+1,nodes) for v in value]} + if kind is dict: + require(len(value)<=64 and all(type(k) is str and len(k.encode('utf-8'))<=128 for k in value),'nested mapping bound') + return {'type':'dict','items':[[k,audit_value(value[k],depth+1,nodes)] for k in sorted(value)]} + raise ValueError('unsupported nested parameter type') + class RecordingResult(unittest.TextTestResult): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs); self.records = []; self.active = None + self.subtest_seen=0;self.subtest_retained=0;self.subtest_bytes=0;self.subtest_complete=True;self.subtest_refused=0;self.subtest_refusals=[] + def startTest(self, test): + super().startTest(test) + identity = test.id(); token = hashlib.sha256(identity.encode()).hexdigest() + row = {'id': identity, 'status': None, 'started_ns': time.monotonic_ns(), + 'stdout': token + '.stdout', 'stderr': token + '.stderr', 'exceptions': [], 'subtests': [], + 'subtests_complete':True,'subtest_events_seen':0,'subtest_metadata_bytes':0,'subtest_refusals':[]} + self.records.append(row); self.active = row + self.saved_streams = sys.stdout, sys.stderr + self.streams = BoundedText(output / row['stdout']), BoundedText(output / row['stderr']) + sys.stdout, sys.stderr = self.streams + def stopTest(self, test): + sys.stdout, sys.stderr = self.saved_streams + for stream in self.streams: stream.close() + self.active['duration_ns'] = time.monotonic_ns() - self.active.pop('started_ns') + self.active['status'] = (self.active['status'] or 'INCOMPLETE') if self.active['subtests_complete'] else 'INCOMPLETE' + self.active = None; super().stopTest(test) + def note(self, status, err=None): + if self.active is not None: + self.active['status'] = status + if err: + text = ''.join(traceback.format_exception(*err)) + require(len(text.encode()) <= 65536, 'per-method exception exceeded 64 KiB') + self.active['exceptions'].append({'type': err[0].__name__, 'traceback': text}) + def addSuccess(self, test): + self.note('PASS'); super().addSuccess(test) + def addFailure(self, test, err): + self.note('FAIL', err); super().addFailure(test, err) + def addError(self, test, err): + self.note('ERROR', err); super().addError(test, err) + def addSkip(self, test, reason): + if isinstance(test,unittest.case._SubTest):self.capture_subtest(test,'SKIP',skip_reason=reason) + self.note('SKIP'); super().addSkip(test, reason) + def addExpectedFailure(self, test, err): + self.note('XFAIL', err); super().addExpectedFailure(test, err) + def addUnexpectedSuccess(self, test): + self.note('XPASS'); super().addUnexpectedSuccess(test) + def capture_subtest(self,subtest,status,exception_type=None,skip_reason=None): + self.subtest_seen+=1;row=self.active + if row is not None:row['subtest_events_seen']+=1 + try: + require(row is not None and self.subtest_complete,'prior or unowned nested observation refused') + require(self.subtest_seen<=2048 and row['subtest_events_seen']<=256,'nested callback count bound') + maps=subtest.params.maps;require(type(maps) is list and 1<=len(maps)<=8,'nested parameter scope bound');nodes=[0];scopes=[] + for mapping in reversed(maps): + require(type(mapping) is dict and len(mapping)<=16 and all(type(k) is str and len(k.encode('utf-8'))<=128 for k in mapping),'closed nested scope') + scopes.append([[k,audit_value(mapping[k],0,nodes)] for k in sorted(mapping)]) + message=subtest._message + message={'kind':'DEFAULT'} if message is unittest.case._subtest_msg_sentinel else {'kind':'VALUE','value':audit_value(message,0,nodes)} + require(exception_type is None or type(exception_type) is str and len(exception_type.encode('utf-8'))<=128,'nested exception type bound') + require(skip_reason is None or type(skip_reason) is str and len(skip_reason.encode('utf-8'))<=2048,'nested skip reason bound') + case={'parent_method_id':row['id'],'ordinal':row['subtest_events_seen'],'mode_ordinal':self.subtest_seen,'scopes':scopes,'message':message} + event={'event_id':hashlib.sha256(audit_encode(case)).hexdigest(),'case':case,'status':status,'exception_type':exception_type,'skip_reason':skip_reason} + wire=audit_encode(event);cost=len(wire)+1;require(len(wire)<=8192 and self.subtest_bytes+cost<=131072,'nested serialized metadata bound') + row['subtests'].append(event);row['subtest_metadata_bytes']+=cost;self.subtest_retained+=1;self.subtest_bytes+=cost + except BaseException: + # Preserve the complete accepted prefix and explicit refusal; never silently truncate or alter an assertion. + self.subtest_complete=False;self.subtest_refused+=1 + refusal={'mode_ordinal':self.subtest_seen,'method_id':row['id'] if row else None,'ordinal':row['subtest_events_seen'] if row else None,'reason':'NESTED_REPRESENTATION_OR_BOUND_REFUSED'} + if len(self.subtest_refusals)<8:self.subtest_refusals.append(refusal) + if row is not None: + row['subtests_complete']=False + if len(row['subtest_refusals'])<8:row['subtest_refusals'].append(refusal) + def addSubTest(self, test, subtest, err): + status='PASS' if err is None else 'FAIL' if issubclass(err[0],test.failureException) else 'ERROR' + self.capture_subtest(subtest,status,err[0].__name__ if err is not None else None) + if err is not None:self.note(status,err) + super().addSubTest(test, subtest, err) + def flatten(value): + if isinstance(value, unittest.TestSuite): + return [item for child in value for item in flatten(child)] + return [value] + record = {'schema_version': 1, 'mode': mode, 'kernel': kernel, 'test_module': 'test_formal_regression', + 'expected_test_ids': expected, 'actual_test_ids': [], 'records': [], 'complete': False, + 'exit_code': 2, 'driver_error': None, 'qualification': 'REQUIRES_NONAUTHOR_NATIVE_ORIGINAL_REVIEW', + 'subtest_audit_contract':SUBTEST_AUDIT_CONTRACT,'subtests_complete':False,'subtest_events_seen':0, + 'subtest_events_retained':0,'subtest_metadata_bytes':0,'subtest_refused_total':0,'subtest_refusals':[]} + try: + # No site packages, no .git, no host credentials and no source-controlled host helper. + sys.path.insert(0, str(root)) + suite = unittest.defaultTestLoader.discover(str(root / 'tests'), pattern='test_formal_regression.py', + top_level_dir=str(root / 'tests')) + actual = sorted(test.id() for test in flatten(suite)) + record['actual_test_ids'] = actual + require(actual == expected and len(actual) > 0 and len(set(actual)) == len(actual), + 'exact nonzero frozen discovery; import failure is HOLD') + result = unittest.TextTestRunner(verbosity=2, resultclass=RecordingResult, failfast=False).run(suite) + record['records'] = result.records + record.update(subtests_complete=result.subtest_complete,subtest_events_seen=result.subtest_seen, + subtest_events_retained=result.subtest_retained,subtest_metadata_bytes=result.subtest_bytes, + subtest_refused_total=result.subtest_refused,subtest_refusals=result.subtest_refusals) + ids = [row['id'] for row in result.records] + complete = sorted(ids) == expected and len(set(ids)) == len(expected) and result.testsRun == len(expected) + allowed = all(row['status'] in ('PASS', 'FAIL') for row in result.records) + record.update(complete=complete and allowed and result.subtest_complete + and all(row['subtests_complete'] and row['subtest_events_seen']==len(row['subtests']) for row in result.records) + and not result.errors and not result.skipped + and not result.expectedFailures and not result.unexpectedSuccesses, + tests_run=result.testsRun, failure_count=len(result.failures), error_count=len(result.errors), + skipped_count=len(result.skipped), expected_failures=len(result.expectedFailures), + unexpected_successes=len(result.unexpectedSuccesses)) + record['exit_code'] = 0 if record['complete'] and result.wasSuccessful() else 1 if record['complete'] else 2 + except BaseException as exc: + record['driver_error'] = {'type': type(exc).__name__, 'message': str(exc)[:2048]} + raw = (json.dumps(record, sort_keys=True, allow_nan=False) + '\n').encode() + if len(raw)>2**20: + # A hash is not the refused original. Preserve explicit bounded incomplete metadata instead. + refused={'bytes':len(raw),'sha256':hashlib.sha256(raw).hexdigest(),'retained':False} + record={'schema_version':1,'mode':mode,'test_module':'test_formal_regression','expected_test_ids':expected,'actual_test_ids':[], + 'records':[],'complete':False,'exit_code':2,'driver_error':{'type':'ResultMetadataOverflow','message':'Full mode metadata refused by existing1MiB cap; no complete method/subtest inventory is claimed'}, + 'subtest_audit_contract':SUBTEST_AUDIT_CONTRACT,'subtests_complete':False,'refused_full_result':refused, + 'qualification':'HOLD_INCOMPLETE; RAW_METHOD_STREAMS_AND_NATIVE_TERMINALS_STILL_REQUIRE_COLLECTION'} + raw=audit_encode(record) + require(len(raw)<=2**20,'bounded explicit per-mode incomplete result') + with (output / 'result.json').open('xb') as stream: + os.fchmod(stream.fileno(), 0o644); stream.write(raw) + raise SystemExit(record['exit_code']) + PY + cat > "$base/control/controller.py" <<'PY' + # All host imports are stdlib. This literal controller requires whole-source review. + import datetime, hashlib, json, math, os, pathlib, re, selectors, signal, stat, subprocess, sys, time + MIB = 2**20 + IMAGE = 'python:3.11.14-slim-bookworm@sha256:83f339c1be6340ae1096010fdccf6552ac932d8f410d45d206014916bdf37e48' + IMAGE_ID = 'sha256:44d8f4434bcb025b8cb5c3151be689a906223e47cc3146971feccda936d2e82b' + DRIVER_PIN = (13827, '4b7d4f02f333c47e8ad98e1123efd3fa32ff37b8d702cf2f6949a090c1900cc6') + PLAN_SHA = 'bbe508fcd9205145435c23559ae93bcb89b51ffc8fc9b48fb959226b22729213' + PLAN_PATH = 'tests/fixtures/formal_regression/control-plan.json' + CORE_PATH = 'architecture/formal_regression.py' + FROZEN_PATHS = {'tests/test_formal_regression.py', 'docs/architecture/formal-regression-contract.json', + 'tests/fixtures/formal_regression/inventory-conformance.json'} + SOURCE_PATHS = sorted(FROZEN_PATHS | {PLAN_PATH, CORE_PATH, '.github/workflows/formal-regression-controls.yml', + '.github/workflows/architecture-runtime-acquisition.yml', 'docs/plans/2026-10-09-public-runtime-acquisition.md', + 'docs/superpowers/specs/2026-10-18-formal-regression-collector-design.md', + 'docs/superpowers/plans/2026-10-18-formal-regression-collector-implementation.md'}) + STAGED_PATHS = FROZEN_PATHS | {PLAN_PATH, CORE_PATH} + ROOT = pathlib.Path(sys.argv[1]); WORKSPACE = pathlib.Path(os.environ['GITHUB_WORKSPACE']) + OUT, CONTROL, SOURCE, PUBLISH = (ROOT / x for x in ('originals', 'control', 'source', 'publish')) + WORKER_IMAGE=pathlib.Path(os.environ['FORMAL_EVIDENCE_TEMP']).parent/'worker-output.img' + deadline = time.monotonic() + 720 + commands, owned, disposed, mode_records = {}, {}, {}, {} + attempted = set() + saved, total, source_before, source_after = {}, 0, {}, {} + failure, cleanup_failure, filesystem_mounted = None, None, False + context = {key: os.environ.get(name,'') for key, name in (('repository','GITHUB_REPOSITORY'), + ('checked_commit','GITHUB_SHA'),('run_id','GITHUB_RUN_ID'),('run_attempt','GITHUB_RUN_ATTEMPT'), + ('event_name','GITHUB_EVENT_NAME'),('ref','GITHUB_REF'),('workflow_ref','GITHUB_WORKFLOW_REF'), + ('workflow_sha','GITHUB_WORKFLOW_SHA'),('job','GITHUB_JOB'))} + def require(value, message): + if not value: raise ValueError(message) + def sha(raw): return hashlib.sha256(raw).hexdigest() + def encode(value): return (json.dumps(value,sort_keys=True,allow_nan=False)+'\n').encode() + SUBTEST_AUDIT_CONTRACT = {'schema_version':1,'scope_order':'OUTER_TO_INNER','events':'UNMODIFIED_STDLIB_SUBTEST_CALLBACKS','event_bytes':8192,'method_events':256,'mode_events':2048,'mode_metadata_bytes':131072,'value_depth':8,'value_nodes':256,'scope_parameters':16,'scopes':8,'container_items':64,'key_bytes':128,'string_bytes':2048,'integer_characters':128} + def validate_subtest_inventory(record,rows): + contract=record['subtest_audit_contract'] + require(type(contract) is dict and set(contract)==set(SUBTEST_AUDIT_CONTRACT) + and all(type(contract[k]) is type(v) for k,v in SUBTEST_AUDIT_CONTRACT.items()),'exact nested audit contract field types') + require(contract==SUBTEST_AUDIT_CONTRACT and record['subtests_complete'] is True + and type(record['subtest_refused_total']) is int and record['subtest_refused_total']==0 and record['subtest_refusals']==[],'complete bounded nested audit contract') + def value(v,depth,nodes): + nodes[0]+=1;require(type(v) is dict and depth<=8 and nodes[0]<=256 and type(v.get('type')) is str,'closed nested typed value');t=v['type'] + if t=='none':require(set(v)=={'type'},'nested none fields') + elif t=='bool':require(set(v)=={'type','value'} and type(v['value']) is bool,'nested bool fields') + elif t=='int': + require(set(v)=={'type','value'} and type(v['value']) is str and len(v['value'])<=128 + and re.fullmatch('-?(0|[1-9][0-9]*)',v['value']) and str(int(v['value']))==v['value'],'canonical nested int') + elif t=='float': + require(set(v)=={'type','value'} and type(v['value']) is str and len(v['value'])<=128,'nested float fields') + f=float.fromhex(v['value']);require(math.isfinite(f) and f.hex()==v['value'],'canonical finite nested float') + elif t=='str':require(set(v)=={'type','value'} and type(v['value']) is str and len(v['value'].encode('utf-8'))<=2048,'nested string fields') + elif t in ('list','tuple','dict'): + require(set(v)=={'type','items'} and type(v['items']) is list and len(v['items'])<=64,'nested sequence/map fields') + if t=='dict': + pairs=v['items'];require(all(type(p) is list and len(p)==2 and type(p[0]) is str and len(p[0].encode('utf-8'))<=128 for p in pairs),'nested map keys') + keys=[p[0] for p in pairs];require(keys==sorted(set(keys)),'canonical unique nested map keys') + for _,item in pairs:value(item,depth+1,nodes) + else: + for item in v['items']:value(item,depth+1,nodes) + else:raise ValueError('unsupported nested typed value') + mode_ordinal=0;mode_bytes=0 + for row in rows: + events=row['subtests'];require(type(events) is list and len(events)<=256 and row['subtests_complete'] is True + and type(row['subtest_events_seen']) is int and row['subtest_events_seen']==len(events) and row['subtest_refusals']==[],'complete nested containing-method inventory');method_bytes=0 + for ordinal,event in enumerate(events,1): + mode_ordinal+=1;require(type(event) is dict and set(event)=={'event_id','case','status','exception_type','skip_reason'},'closed nested event fields') + case=event['case'];require(type(case) is dict and set(case)=={'parent_method_id','ordinal','mode_ordinal','scopes','message'} + and case['parent_method_id']==row['id'] and type(case['ordinal']) is int and case['ordinal']==ordinal + and type(case['mode_ordinal']) is int and case['mode_ordinal']==mode_ordinal,'deterministic nested method/order identity') + scopes=case['scopes'];require(type(scopes) is list and 1<=len(scopes)<=8,'nested scope inventory');nodes=[0] + for scope in scopes: + require(type(scope) is list and len(scope)<=16 and all(type(p) is list and len(p)==2 and type(p[0]) is str and len(p[0].encode('utf-8'))<=128 for p in scope),'closed nested parameter scope') + keys=[p[0] for p in scope];require(keys==sorted(set(keys)),'canonical unique nested parameter names') + for _,item in scope:value(item,0,nodes) + message=case['message'];require(type(message) is dict and message.get('kind') in ('DEFAULT','VALUE'),'nested message kind') + if message['kind']=='DEFAULT':require(set(message)=={'kind'},'default nested message fields') + else:require(set(message)=={'kind','value'},'explicit nested message fields');value(message['value'],0,nodes) + require(type(event['event_id']) is str and event['event_id']==sha(encode(case)),'full deterministic nested event identity') + status=event['status'];exception=event['exception_type'];reason=event['skip_reason'] + require(status in ('PASS','FAIL','ERROR','SKIP') and (exception is None or type(exception) is str and 0=0 and count+members<=ordinary_member_limit+(32 if extra else 0) + and current+size<=ordinary_byte_limit+(2*MIB if extra else 0),'shared retained-original reservation exhausted') + def save(name, raw, limit=MIB, recovery=False): + global total + require(re.fullmatch(r'[A-Za-z0-9_.-]+',name) and name not in saved and len(raw)<=limit,'host original name/type/limit') + budget_admit(len(raw),recovery=recovery) + fd=os.open(OUT/name,os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,0o600) + with os.fdopen(fd,'wb') as stream: stream.write(raw) + saved[name]={'bytes':len(raw),'sha256':sha(raw)}; total+=len(raw) + def command(name, argv, seconds=30, limit=MIB, allow_nonzero=False, recovery=False): + require(name not in commands,'one native command attempt') + if recovery:limit=min(limit,65536) + if not recovery:budget_admit(2*limit+65536,members=3) + timeout=min(seconds,max(0,deadline-time.monotonic())) if not recovery else seconds + require(timeout>0,'reserved phase budget exhausted') + record={'argv':argv,'attempts':1,'timeout_seconds':timeout,'complete':False,'code':None,'timed_out':False, + 'process_unreaped':False,'termination_errors':[],'stream_limit_bytes':limit} + buffers={'stdout':bytearray(),'stderr':bytearray()}; proc=None; selector=selectors.DefaultSelector() + started=time.monotonic_ns() + env={'PATH':'/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin','LANG':'C.UTF-8','TZ':'UTC', + 'DOCKER_CONFIG':str(ROOT/'client'),'GIT_CONFIG_NOSYSTEM':'1','GIT_CONFIG_GLOBAL':'/dev/null','GIT_TERMINAL_PROMPT':'0'} + active=ROOT/'active-command.json' + with active.open('xb') as stream: stream.write(encode({'name':name,'state':'SPAWNING','argv':argv})) + try: + proc=subprocess.Popen(argv,stdin=subprocess.DEVNULL,stdout=subprocess.PIPE,stderr=subprocess.PIPE, + cwd=WORKSPACE,env=env,start_new_session=True) + for stream,label in ((proc.stdout,'stdout'),(proc.stderr,'stderr')): + os.set_blocking(stream.fileno(),False); selector.register(stream,selectors.EVENT_READ,label) + end=time.monotonic()+timeout + while selector.get_map(): + remaining=end-time.monotonic() + if remaining<=0: raise TimeoutError('bounded native command timeout') + for key,_ in selector.select(min(remaining,0.2)): + part=os.read(key.fileobj.fileno(),65536) + if not part: selector.unregister(key.fileobj);key.fileobj.close();continue + room=limit-len(buffers[key.data]);buffers[key.data].extend(part[:room]) + require(len(part)<=room,'native raw stream exceeded bound') + record['code']=proc.wait(timeout=max(0.01,end-time.monotonic()));record['complete']=True + except BaseException as exc: + record['error_type']=type(exc).__name__;record['timed_out']=isinstance(exc,(TimeoutError,subprocess.TimeoutExpired)) + finally: + if proc is not None and proc.poll() is None: + for sig,grace in ((signal.SIGTERM,4),(signal.SIGKILL,1)): + if proc.poll() is not None: break + try: os.killpg(proc.pid,sig);proc.wait(timeout=grace) + except ProcessLookupError: pass + except subprocess.TimeoutExpired: pass + except BaseException as exc: record['termination_errors'].append(type(exc).__name__) + record['process_unreaped']=proc.poll() is None + if proc is not None: + record['code']=proc.returncode + for stream in (proc.stdout,proc.stderr): + if stream is not None and not stream.closed: stream.close() + selector.close();record['duration_ns']=time.monotonic_ns()-started + if proc is not None and proc.poll() is not None and not record['termination_errors']: + active.unlink() + if record['process_unreaped'] or record['termination_errors']:record['complete']=False + process_complete=record['complete'] and (allow_nonzero or record['code']==0) + commands[name]=record + for label,buffer in buffers.items(): + try: save(name+'.'+label,bytes(buffer),limit,recovery=recovery);record[label]=saved[name+'.'+label] + except BaseException as exc:record['complete']=False;record[label+'_capture_error']=type(exc).__name__ + try:save(name+'.status.json',encode(record),65536,recovery=recovery) + except BaseException as exc:record['complete']=False;record['status_capture_error']=type(exc).__name__ + # Exhausted logging never licenses success, but cannot block already observed owned physical cleanup. + require(process_complete and (record['complete'] or recovery),'native command failed: '+name) + return bytes(buffers['stdout']) + def git(name,args,limit=MIB): + return command(name,['git','--no-pager','-c','core.hooksPath=/dev/null','-c','core.fsmonitor=false',*args],limit=limit) + def source_records(phase): + records={} + for index,path in enumerate(SOURCE_PATHS): + raw=read(WORKSPACE/path) + native=git(phase+'-source-'+str(index),['show',context['checked_commit']+':'+path]) + require(raw==native,'worktree/native source mismatch') + native_row=git(phase+'-mode-'+str(index),['ls-tree','--format=%(objectmode) %(objecttype) %(objectname)',context['checked_commit'],'--',path]).decode().strip().split() + require(len(native_row)==3 and native_row[0]=='100644' and native_row[1]=='blob' + and re.fullmatch('[0-9a-f]{40}',native_row[2]),'native regular blob mode/identity') + records[path]={'bytes':len(raw),'sha256':sha(raw),'git_blob':native_row[2],'git_mode':native_row[0]} + if phase=='before': + save('source-'+str(index)+'.original',raw) + if path in STAGED_PATHS: + target=SOURCE/path;target.parent.mkdir(mode=0o755,parents=True,exist_ok=True) + fd=os.open(target,os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,0o444) + with os.fdopen(fd,'wb') as stream:stream.write(raw) + save('source-'+phase+'.json',encode(records));return records + def labels(mode):return {'org.formal-controls.run-id':context['run_id'],'org.formal-controls.attempt':context['run_attempt'], + 'org.formal-controls.checked-commit':context['checked_commit'],'org.formal-controls.mode':str(mode)} + def inspect(mode,label,recovery=False): + rows=strict(command(label,['docker','inspect',owned[mode]],recovery=recovery)) + require(type(rows) is list and len(rows)==1 and rows[0]['Id']==owned[mode] + and rows[0]['Image']==IMAGE_ID and rows[0]['Config']['Labels']==labels(mode),'owned native identity') + return rows[0] + def dispose(mode): + require(not any(v['process_unreaped'] for v in commands.values()),'unreaped command prevents racing disposal') + item=inspect(mode,'dispose-before-'+str(mode),recovery=True) + if item['State']['Running']:command('stop-'+str(mode),['docker','stop','--time','2',owned[mode]],recovery=True) + command('rm-'+str(mode),['docker','rm',owned[mode]],recovery=True) + remaining=command('absent-'+str(mode),['docker','ps','--all','--no-trunc','--filter','id='+owned[mode],'--format','{{json .}}'],recovery=True) + require(remaining==b'','owned container disposal unconfirmed');disposed[mode]=True + def validate_native(item,mode): + c,h=item['Config'],item['HostConfig'] + require(c['Image']==IMAGE and c['User']=='65532:65532' and c['Entrypoint']==['/usr/local/bin/python'] + and c['Cmd']==['-I','-B','-S',*(['-O'] if mode else []),'/control/driver.py',str(mode)] + and c['WorkingDir']=='/' and c['Labels']==labels(mode),'fixed worker command') + require(h['ReadonlyRootfs'] is True and h['NetworkMode']=='none' and h['NanoCpus']==2000000000 + and h['Memory']==h['MemorySwap']==1073741824 and h['PidsLimit']==128 and h['CapDrop']==['ALL'] + and h['CapAdd'] is None and h['SecurityOpt']==['no-new-privileges'] and h['Privileged'] is False + and h['LogConfig']=={'Type':'none','Config':{}} and h['ShmSize']==MIB + and h['Tmpfs']=={'/tmp':'rw,noexec,nosuid,nodev,size=128m,mode=1777'} + and h['Devices']==[] and h['DeviceRequests'] is None and h['VolumesFrom'] is None + and h['PortBindings']=={} and h['PublishAllPorts'] is False and h['PidMode']=='' + and h['IpcMode']=='private' and h['CgroupnsMode']=='private','native kernel isolation/resource limits') + expected={('/source',str(SOURCE)):False,('/control/driver.py',str(CONTROL/'driver.py')):False, + ('/output',str(ROOT/'output'/str(mode))):True} + mounts={(v['Destination'],v['Source']):v['RW'] for v in item['Mounts']} + require(len(item['Mounts'])==3 and mounts==expected and all(v['Type']=='bind' and v['Propagation']=='rprivate' + for v in item['Mounts']),'exact read-only source/control and bounded output mounts') + if len(sys.argv) == 3 and sys.argv[2] == '--recover-and-seal': + with (PUBLISH/'recovery-started.json').open('xb') as stream: + stream.write(encode({'status':'HOLD_RECOVERY_NOT_YET_CONFIRMED','context':context,'scientific_effect':'NONE'})) + early_total=0 + for path in sorted(OUT.iterdir(),key=lambda p:p.name): + try: + require(re.fullmatch(r'[A-Za-z0-9_.-]+',path.name),'closed early original name') + raw=read(path,4*MIB);early_total+=len(raw);require(early_total<=36*MIB,'early partial original bound') + target=PUBLISH/path.name + if not target.exists(): + with target.open('xb') as stream:stream.write(raw) + except BaseException:pass + recovery_errors=[]; physical_clear=False; recovered_ids=[] + if (ROOT/'active-command.json').exists(): + try:save('outer-active-command.json',read(ROOT/'active-command.json',65536),65536) + except BaseException:pass + try: + require(not (ROOT/'active-command.json').exists(), + 'interrupted native command remains uncertain; no racing disposal or worker-output collection') + for mode in (0,1): + name='formal-regression-'+context['run_id']+'-'+context['run_attempt']+'-'+str(mode) + raw=command('outer-discover-'+str(mode),['docker','ps','--all','--no-trunc','--filter','name=^/'+name+'$', + '--format','{{json .}}'],recovery=True) + rows=[strict(line) for line in raw.splitlines()] + require(len(rows)<=1,'ambiguous owned container discovery') + if rows: + objects=strict(command('outer-inspect-'+str(mode),['docker','inspect',rows[0]['ID']],recovery=True)) + require(type(objects) is list and len(objects)==1 and objects[0]['Id']==rows[0]['ID'] + and objects[0]['Image']==IMAGE_ID and objects[0]['Config']['Image']==IMAGE + and objects[0]['Config']['Labels']==labels(mode),'actual image/labels establish recovery ownership') + identity=objects[0]['Id'];recovered_ids.append(identity) + command('outer-remove-'+str(mode),['docker','rm','--force',identity],recovery=True) + absent=command('outer-absent-'+str(mode),['docker','ps','--all','--no-trunc','--filter','id='+identity, + '--format','{{json .}}'],recovery=True) + require(absent==b'','owned disposal after interrupted controller unconfirmed') + physical_clear=True + except BaseException as exc:recovery_errors.append({'type':type(exc).__name__,'message':str(exc)[:2048]}) + # Only named worker originals are considered, and only after physical disposal is known. + if physical_clear: + try: + plan_raw=read(SOURCE/PLAN_PATH);require(sha(plan_raw)==PLAN_SHA,'recovery frozen plan pin') + expected=strict(plan_raw)['test_ids'] + for mode in (0,1): + names={'result.json'}|{sha(v.encode())+suffix for v in expected for suffix in ('.stdout','.stderr')} + for name in sorted(names): + try: + raw=read(ROOT/'output'/str(mode)/name,MIB if name=='result.json' else 131072) + target='worker-'+str(mode)+'-'+name + if (OUT/target).exists():require(read(OUT/target)==raw,'existing worker original changed') + else:save(target,raw,MIB if name=='result.json' else 131072) + except FileNotFoundError:pass + except BaseException as exc:recovery_errors.append({'type':type(exc).__name__,'message':str(exc)[:2048]}) + try: + raw=command('outer-mount-state',['findmnt','--json','--mountpoint',str(ROOT/'output')],allow_nonzero=True,recovery=True) + state=strict(raw) if raw.strip() else {'filesystems':[]} + mounted=state.get('filesystems',[]) + require(len(mounted)<=1,'ambiguous output mount') + if mounted: + require(mounted[0]['target']==str(ROOT/'output') and mounted[0].get('fstype')=='ext4', + 'owned output mount native identity') + loop=str(mounted[0]['source']).split('[')[0] + backing=command('outer-loop-backing',['losetup','--noheadings','--output','BACK-FILE',loop],recovery=True).decode().strip() + require(backing==str(WORKER_IMAGE),'owned loop backing identity') + command('outer-unmount',['sudo','-n','umount',str(ROOT/'output')],recovery=True) + except BaseException as exc:recovery_errors.append({'type':type(exc).__name__,'message':str(exc)[:2048]}) + for name in ('control-process.stdout','control-process.stderr'): + try:save('outer-'+name,read(ROOT/name,4*MIB),4*MIB) + except FileNotFoundError:pass + except BaseException as exc:recovery_errors.append({'type':type(exc).__name__,'message':name+':'+type(exc).__name__}) + observation={'schema_version':1,'context':context,'always_run_recovery':True,'owned_workers_confirmed_absent':physical_clear, + 'recovered_container_ids':recovered_ids,'errors':recovery_errors,'qualification':'HOLD_UNLESS_MAIN_CONTROLLER_AND_NONAUTHOR_ORIGINAL_REVIEW_QUALIFY', + 'scientific_effect':'NONE','custody_authentication':'UNKNOWN'} + save('outer-recovery.json',encode(observation)) + members=[];refused=[];count=0;subtotal=0 + for path in sorted(OUT.iterdir(),key=lambda p:p.name): + count+=1 + try: + require(count<=1024 and re.fullmatch(r'[A-Za-z0-9_.-]+',path.name),'closed original name/count') + raw=read(path,4*MIB);subtotal+=len(raw);require(prep_bytes+subtotal+15*MIB<=64*MIB,'shared partial original aggregate with final reserve') + target=PUBLISH/path.name + if target.exists():require(read(target,4*MIB)==raw,'original already staged copy differs') + else: + with target.open('xb') as stream:stream.write(raw) + members.append({'path':path.name,'bytes':len(raw),'sha256':sha(raw)}) + except BaseException as exc:refused.append({'name_sha256':sha(path.name.encode()),'reason':type(exc).__name__}) + summary={'schema_version':1,'context':context,'available_originals':members,'available_original_bytes':sum(v['bytes'] for v in members), + 'refused':refused,'recovery':observation,'full8':'ACTIVE_UNMET','scientific_effect':'NONE', + 'native_archive_raw_member_readback':'REQUIRED_AFTER_JOB','source_test_exposed':True,'organizational_independence':0} + raw=encode(summary);require(len(raw)<=MIB,'partial collection metadata bound') + with (PUBLISH/'post-control-collection.json').open('xb') as stream:stream.write(raw) + raise SystemExit(0 if physical_clear and not recovery_errors and not refused else 1) + try: + require(re.fullmatch('[0-9a-f]{40}',context['workflow_sha']) and context['workflow_ref'].startswith( + context['repository']+'/.github/workflows/formal-regression-controls.yml@'), 'native workflow source identity missing') + require(context['event_name']=='pull_request' and context['repository']=='d6g8k5htny-coder/main' + and re.fullmatch(r'refs/pull/[1-9][0-9]*/merge',context['ref']) + and re.fullmatch('[0-9a-f]{40}',context['checked_commit']) + and re.fullmatch('[1-9][0-9]*',context['run_id']) and re.fullmatch('[1-9][0-9]*',context['run_attempt']), + 'natural current PR merge event required') + event_raw=read(pathlib.Path(os.environ['GITHUB_EVENT_PATH']),4*MIB);event=strict(event_raw);pr=event['pull_request'] + event_context={'number':event['number'],'action':event['action'],'head':pr['head']['sha'],'base':pr['base']['sha'], + 'head_repository':pr['head']['repo']['full_name'],'base_repository':pr['base']['repo']['full_name'], + 'base_ref':pr['base']['ref'],'merge_commit_sha':pr['merge_commit_sha'],'event_bytes':len(event_raw),'event_sha256':sha(event_raw)} + require(event_context['base_repository']==context['repository'] and event_context['base_ref']=='main' + and event_context['merge_commit_sha']==context['checked_commit'] + and context['ref']=='refs/pull/'+str(event_context['number'])+'/merge','event/head/base/merge join') + require(event_context['action'] in ('opened','synchronize','reopened','ready_for_review') + and type(event_context['number']) is int and event_context['number']>0 + and all(re.fullmatch('[0-9a-f]{40}',event_context[k]) for k in ('head','base','merge_commit_sha')) + and re.fullmatch(r'[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+',event_context['head_repository']), 'closed native-event allowlist types') + event_custody={'schema_version':1,'interface':'formal-controls-native-event-custody/v1','native_context':context, + 'allowlisted_projection':event_context,'raw_event_pin':{'bytes':len(event_raw),'sha256':sha(event_raw)}, + 'raw_event_original':None,'raw_event_source_join':'UNRESOLVED_NOT_RETAINED','native_acceptance':None, + 'projection_is_original':False,'source_join_qualified':False, + 'required_external_original':{'audience':'ACTUALLY_QUALIFIED_PRIVATE_OR_APPROVED_NATIVE_CARRIER','immutable_original_identity':None, + 'native_repository_run_attempt_job_and_workflow_source':None,'raw_bytes_pin_equality':None,'current_audience_readback':None}, + 'external_original_closed_contract':{'type':'NativeEventOriginal/v1','actual':None, + 'closed_fields':['schema_version','repository','checked_commit','run_id','run_attempt','job_id','workflow_source_ref','carrier_native_id','carrier_version','member_id','bytes','sha256','audience_evidence_ref','native_source_observation_ref','raw_readback_observation_ref'], + 'types':{'schema_version':'exact int1 not bool','repository':'exact native repository','checked_commit':'lowercase40hex exact nativeK', + 'run_id':'positive ASCII decimal string','run_attempt':'positive ASCII decimal string','job_id':'positive ASCII decimal string', + 'workflow_source_ref':'closed six-field immutable GitRef, separately native-bound','carrier_native_id':'opaque actual immutable native identity, never URL', + 'carrier_version':'exact immutable observed version','member_id':'safe carrier-relative immutable member identity','bytes':'exact nonnegative int<=4MiB not bool', + 'sha256':'lowercase64hex equal raw_event_pin','audience_evidence_ref':'actual immutable qualified audience original identity', + 'native_source_observation_ref':'actual immutable native repository/run/attempt/job/source observation identity','raw_readback_observation_ref':'actual immutable raw-byte readback identity'}, + 'admission':'External qualified nonauthor must rejoin every native field, exact raw pin/projection and audience before credit; no input boolean/status/hash supplies authentication'}, + 'public_allowlist':['number','action','head','base','head_repository','base_repository','base_ref','merge_commit_sha','event_bytes','event_sha256'], + 'excluded':'PR bodies/titles/comments/actors/access URLs/credentials/private metadata; no raw event body is published', + 'qualification':'HOLD; hash/projection never replaces unavailable original or authenticated native custody'} + save('native-context.json',encode(context));save('event-context.json',encode(event_context));save('event-custody-interface.json',encode(event_custody)) + save('shared-budget-policy.json',budget_policy_raw,65536);save('preparation-account.json',budget_account_raw) + require(git('actual-HEAD',['rev-parse','HEAD']).decode().strip()==context['checked_commit'], 'actual checked HEAD equality') + for role in ('head','base'): + git('native-'+role+'-commit',['cat-file','-p',event_context[role]],limit=65536) + commit=git('checked-commit',['cat-file','-p',context['checked_commit']],limit=65536) + lines=commit.decode().splitlines();tree=[v[5:] for v in lines if v.startswith('tree ')] + parents=[v[7:] for v in lines if v.startswith('parent ')] + require(len(tree)==1 and parents==[event_context['base'],event_context['head']],'actual checked merge tree/parents') + save('checked-tree-parents.json',encode({'tree':tree[0],'parents':parents})) + prep=read(pathlib.Path(os.environ['FORMAL_EVIDENCE_TEMP'])/('formal-regression-preparation-binding-'+context['run_id']+'-'+context['run_attempt']+'.json'),2*MIB) + preparation=strict(prep);save('preparation-binding.json',prep,2*MIB) + require(preparation['native_context']=={k:context[k] for k in ('repository','checked_commit','run_id','run_attempt')} + and preparation['daemon_recovery_complete'] is True,'same-attempt preparation binding') + source_before=source_records('before') + require(source_before[PLAN_PATH]['sha256']==PLAN_SHA,'independently frozen literal control-plan identity') + plan=strict(read(SOURCE/PLAN_PATH));require(set(plan)=={'organization_independence', 'request_key_oracle', 'test_module', 'expected_scaffold_summary', 'qualified_GREEN', 'runtime_status', 'frozen_at_utc', 'all8', 'qualified_RED', 'held_predicates', 'mode_inventory', 'scope_limits', 'kind', 'test_ids', 'control_plan_state', 'schema_version', 'commands', 'methods', 'synthetic_test_boundary_profile', 'mandatory_contract_coverage', 'remaining_Task1_requirements', 'scientific_effect', 'frozen_sources', 'minimal_core_preimage'},'closed control-plan fields') + require(type(plan['schema_version']) is int and plan['schema_version']==1 and plan['test_module']=='test_formal_regression' + and type(plan['test_ids']) is list and 00 + and re.fullmatch('[0-9a-f]{64}',historical['sha256']) and type(historical['role']) is str and historical['role'], + 'separate historical minimal-scaffold descriptor; no workflow/self hash') + for name in ('controller.py','driver.py'): + raw=read(CONTROL/name) + if name=='driver.py':require((len(raw),sha(raw))==DRIVER_PIN,'fixed literal recording driver identity') + save(name,raw) + # Root source directory traversable by UID65532; only the closed five staged files are mounted. + SOURCE.chmod(0o755) + for directory in SOURCE.rglob('*'): + if directory.is_dir():directory.chmod(0o755) + command('output-truncate',['truncate','-s','64M',str(WORKER_IMAGE)]) + command('output-format',['mkfs.ext4','-F',str(WORKER_IMAGE)]) + command('output-mount',['sudo','-n','mount','-o','loop,nodev,nosuid,noexec',str(WORKER_IMAGE),str(ROOT/'output')]);filesystem_mounted=True + for mode in (0,1): + target=ROOT/'output'/str(mode) + command('output-directory-'+str(mode),['sudo','-n','mkdir','-m','0777',str(target)]) + command('output-capacity',['df','-B1',str(ROOT/'output')]) + client_info=(ROOT/'client').lstat() + require(stat.S_ISDIR(client_info.st_mode) and stat.S_IMODE(client_info.st_mode)==0o700 + and client_info.st_uid==os.getuid() and list((ROOT/'client').iterdir())==[], 'fresh empty private Docker client') + image=strict(command('runtime-image',['docker','image','inspect',IMAGE])) + require(type(image) is list and len(image)==1 and image[0]['Id']==IMAGE_ID + and image[0]['RepoDigests']==['python@sha256:83f339c1be6340ae1096010fdccf6552ac932d8f410d45d206014916bdf37e48'] + and image[0]==preparation['image'],'same unmodified prepared native image') + image_env=image[0]['Config']['Env'];expected_env=[v for v in image_env if not v.startswith(('LANG=','TZ=','PYTHONDONTWRITEBYTECODE='))]+['LANG=C.UTF-8','TZ=UTC','PYTHONDONTWRITEBYTECODE=1'] + for mode in (0,1): + name='formal-regression-'+context['run_id']+'-'+context['run_attempt']+'-'+str(mode) + argv=['docker','create','--pull=never','--name',name,'--platform','linux/amd64','--network','none', + '--read-only','--user','65532:65532','--cpus','2','--memory','1g','--memory-swap','1g','--pids-limit','128', + '--cap-drop','ALL','--security-opt','no-new-privileges','--log-driver','none','--ipc','private','--cgroupns','private', + '--shm-size','1m','--ulimit','fsize=67108864:67108864','--ulimit','nofile=256:256','--ulimit','msgqueue=8192:8192', + '--tmpfs','/tmp:rw,noexec,nosuid,nodev,size=128m,mode=1777','--mount','type=bind,src='+str(SOURCE)+',dst=/source,readonly', + '--mount','type=bind,src='+str(CONTROL/'driver.py')+',dst=/control/driver.py,readonly', + '--mount','type=bind,src='+str(ROOT/'output'/str(mode))+',dst=/output', + '--workdir','/','--env','LANG=C.UTF-8','--env','TZ=UTC','--env','PYTHONDONTWRITEBYTECODE=1','--entrypoint','/usr/local/bin/python'] + for key,value in labels(mode).items():argv+=['--label',key+'='+value] + argv += [IMAGE,'-I','-B','-S',*(['-O'] if mode else []),'/control/driver.py',str(mode)] + attempted.add(mode) + identity=command('create-'+str(mode),argv).decode().strip() + require(re.fullmatch('[0-9a-f]{64}',identity),'native created container ID');owned[mode]=identity + try: + before=inspect(mode,'before-'+str(mode));validate_native(before,mode) + require(sorted(before['Config']['Env'])==sorted(expected_env),'closed credential-free worker environment') + command('attach-'+str(mode),['docker','start','--attach',identity],seconds=300,allow_nonzero=True) + waited=command('wait-'+str(mode),['docker','wait',identity]).decode().strip() + after=inspect(mode,'after-'+str(mode));validate_native(after,mode) + require(before['Config']==after['Config'] and before['HostConfig']==after['HostConfig'] + and after['State']['Status']=='exited' and after['State']['Running'] is False + and after['State']['OOMKilled'] is False and after['State']['Error']=='' + and waited==str(after['State']['ExitCode']),'native terminal state and exit join') + mode_records[str(mode)]={'before':before,'after':after,'native_exit':after['State']['ExitCode']} + finally: + dispose(mode) + source_after=source_records('after');require(source_after==source_before,'all consumed source originals stable') + except BaseException as exc: + failure={'type':type(exc).__name__,'message':str(exc)[:2048]} + finally: + try: + require(not any(v['process_unreaped'] for v in commands.values()), 'uncertain native command prevents recovery races') + for mode in sorted(attempted - set(owned)): + name='formal-regression-'+context['run_id']+'-'+context['run_attempt']+'-'+str(mode) + raw=command('adopt-discover-'+str(mode),['docker','ps','--all','--no-trunc','--filter','name=^/'+name+'$', + '--format','{{json .}}'],recovery=True) + rows=[strict(line) for line in raw.splitlines()] + require(len(rows)<=1,'ambiguous failed-creation ownership') + if rows: + native=strict(command('adopt-inspect-'+str(mode),['docker','inspect',rows[0]['ID']],recovery=True)) + require(type(native) is list and len(native)==1 and native[0]['Image']==IMAGE_ID + and native[0]['Config']['Labels']==labels(mode) and native[0]['Id']==rows[0]['ID'], + 'native failed-creation image/label ownership') + owned[mode]=native[0]['Id'] + for mode in owned: + if not disposed.get(mode):dispose(mode) + require(all(disposed.get(mode) is True for mode in owned),'owned physical disposal before collection') + require(not any(v['process_unreaped'] for v in commands.values()),'unreaped native command; collection refused') + except BaseException as exc:cleanup_failure={'type':type(exc).__name__,'message':str(exc)[:2048]} + # Candidate outputs are untrusted observations, never proof or self-issued qualification. + copied,refused,missing=[],[],[] + if cleanup_failure is None and all(disposed.get(mode) is True for mode in owned): + try: + expected=plan['test_ids'] if 'plan' in globals() else [] + for mode in (0,1): + directory=ROOT/'output'/str(mode) + names={'result.json'}|{hashlib.sha256(v.encode()).hexdigest()+suffix for v in expected for suffix in ('.stdout','.stderr')} + if directory.exists(): + for path in directory.iterdir(): + if path.name not in names:refused.append({'mode':mode,'reason':'UNDECLARED_OUTPUT_NAME','name_sha256':sha(path.name.encode())}) + for name in sorted(names): + try: + raw=read(directory/name,MIB if name=='result.json' else 131072) + save('worker-'+str(mode)+'-'+name,raw,MIB if name=='result.json' else 131072) + copied.append('worker-'+str(mode)+'-'+name) + except FileNotFoundError:missing.append('worker-'+str(mode)+'-'+name) + except BaseException as exc:refused.append({'mode':mode,'name':name,'reason':type(exc).__name__}) + require(not missing and not refused and len(mode_records)==2,'complete bounded worker originals required') + results={str(mode):strict(read(OUT/('worker-'+str(mode)+'-result.json'))) for mode in (0,1)} + for mode in (0,1): + r=results[str(mode)];rows=r['records'];ids=[v['id'] for v in rows] + require(r['schema_version']==1 and r['mode']==mode and r['test_module']=='test_formal_regression' + and r['expected_test_ids']==r['actual_test_ids']==expected and sorted(ids)==expected + and len(set(ids))==len(expected)==r['tests_run'] and r['complete'] is True + and r['error_count']==r['skipped_count']==r['expected_failures']==r['unexpected_successes']==0 + and all(v['status'] in ('PASS','FAIL') and v['stdout']==sha(v['id'].encode())+'.stdout' + and v['stderr']==sha(v['id'].encode())+'.stderr' for v in rows) and r['driver_error'] is None + and r['exit_code']==mode_records[str(mode)]['native_exit'] in (0,1),'exact full method/result/native exit completeness') + validate_subtest_inventory(r,rows) + k=r['kernel'];quota,period=map(int,k['cgroup']['cpu.max'].split()) + require(k['uid']==k['gid']==65532 and k['proc_status']=={'CapEff':'0000000000000000','NoNewPrivs':'1'} + and k['cgroup']['memory.max']=='1073741824' and k['cgroup']['pids.max']=='128' + and quota==2*period and period>0 and k['network_interfaces']==['lo'] and len(k['network_routes'])==1 + and 0=end:record['timeout']=True;raise TimeoutError('trusted controller time cap') + for key,_ in selector.select(min(0.2,max(0,end-time.monotonic()))): + part=os.read(key.fileobj.fileno(),65536) + if not part:selector.unregister(key.fileobj);key.fileobj.close();continue + room=1048576-sizes[key.data];kept=part[:room];streams[key.data].write(kept);digests[key.data].update(kept);sizes[key.data]+=len(kept) + if len(part)>room:record['stream_truncated'][key.data]=True;raise ValueError('trusted controller stream exceeded one MiB') + record['exit_code']=proc.wait(timeout=max(0.01,end-time.monotonic()));record['complete']=True + except BaseException as exc:record['error']=type(exc).__name__ + finally: + if proc is not None and proc.poll() is None: + for sig,grace in ((signal.SIGTERM,4),(signal.SIGKILL,1)): + if proc.poll() is not None:break + try:os.killpg(proc.pid,sig);proc.wait(timeout=grace) + except (ProcessLookupError,subprocess.TimeoutExpired):pass + except BaseException as exc:record['termination_errors'].append(type(exc).__name__) + record['process_unreaped']=proc.poll() is None + if proc is not None: + record['exit_code']=proc.returncode + for pipe in (proc.stdout,proc.stderr): + try: + if pipe is not None and not pipe.closed:pipe.close() + except BaseException as exc:record['termination_errors'].append('PIPE:'+type(exc).__name__) + try:selector.close() + except BaseException as exc:record['termination_errors'].append('SELECTOR:'+type(exc).__name__) + for stream in streams.values(): + try:stream.flush();os.fsync(stream.fileno());stream.close() + except BaseException as exc:record['termination_errors'].append('STREAM:'+type(exc).__name__) + if record['process_unreaped'] or record['termination_errors']:record['complete']=False + record['captured_stream_bytes']=sizes;record['duration_ns']=time.monotonic_ns()-started + record['streams']={k:{'path':prefix+'.'+k,'bytes':sizes[k],'sha256':digests[k].hexdigest(),'complete':record['complete'] and not record['stream_truncated'][k]} for k in streams} + status=(json.dumps(record,sort_keys=True)+'\n').encode() + if len(status)>65536:raise ValueError('launcher terminal metadata exceeded reserved64KiB') + with (base/(prefix+'.status.json')).open('xb') as stream:stream.write(status);stream.flush();os.fsync(stream.fileno()) + if proc is not None and proc.poll() is not None and not record['termination_errors']:active.unlink() + raise SystemExit(0 if record['complete'] and not record['process_unreaped'] and record['exit_code']==0 else 1) + PY + - name: Recover only owned workers and retain bounded partials + if: always() + timeout-minutes: 4 + run: | + set -euo pipefail + base="$FORMAL_EVIDENCE_TEMP/formal-regression-$GITHUB_RUN_ID-$GITHUB_RUN_ATTEMPT" + if [ ! -f "$base/control/controller.py" ]; then + mkdir -p -m 0700 "$base/publish" + printf '%s\n' '{"status":"HOLD","first_missing_predicate":"TRUSTED_CONTROLLER_SOURCE_NOT_CREATED","runtime":"NOT_RUN","scientific_effect":"NONE"}' > "$base/publish/setup-hold.json" + exit 1 + fi + python3 -I -B -S - "$base" recovery <<'PY' + import hashlib,json,os,pathlib,selectors,signal,stat,subprocess,sys,time + base=pathlib.Path(sys.argv[1]);mode=sys.argv[2] + if mode not in ('main','recovery'):raise ValueError('closed launcher role') + native={key:os.environ[name] for key,name in (('repository','GITHUB_REPOSITORY'),('checked_commit','GITHUB_SHA'),('run_id','GITHUB_RUN_ID'),('run_attempt','GITHUB_RUN_ATTEMPT'))} + path=base/'control/controller.py';parent=os.open(path.anchor,os.O_RDONLY|os.O_DIRECTORY|os.O_NOFOLLOW) + try: + for part in path.parts[1:-1]: + child=os.open(part,os.O_RDONLY|os.O_DIRECTORY|os.O_NOFOLLOW,dir_fd=parent);os.close(parent);parent=child + fd=os.open(path.name,os.O_RDONLY|os.O_NOFOLLOW|os.O_NONBLOCK,dir_fd=parent) + finally:os.close(parent) + try: + before=os.fstat(fd);raw=b'' + while len(raw)<=1048576: + part=os.read(fd,min(65536,1048577-len(raw))) + if not part:break + raw+=part + after=os.fstat(fd) + if not stat.S_ISREG(before.st_mode) or before.st_nlink!=1 or len(raw)!=48421 or hashlib.sha256(raw).hexdigest()!='be2584393aa236bb70cef9b9fec6e0f117e3725dc24a31d064871f3832799f75' or (before.st_dev,before.st_ino,before.st_size,before.st_mtime_ns,before.st_ctime_ns)!=(after.st_dev,after.st_ino,after.st_size,after.st_mtime_ns,after.st_ctime_ns): + raise ValueError('fixed literal controller original pin/type/unchanged mismatch') + finally:os.close(fd) + prefix='control-process' if mode=='main' else 'recovery-process' + argv=[sys.executable,'-I','-B','-S',str(path),str(base),*(['--recover-and-seal'] if mode=='recovery' else [])] + streams={k:(base/(prefix+'.'+k)).open('xb') for k in ('stdout','stderr')};sizes={k:0 for k in streams};digests={k:hashlib.sha256() for k in streams} + record={'schema_version':1,'native_context':native,'role':mode,'controller_source':{'bytes':len(raw),'sha256':hashlib.sha256(raw).hexdigest()},'argv':argv, + 'complete':False,'process_created':False,'exit_code':None,'timeout':False,'process_unreaped':False,'error':None,'termination_errors':[], + 'stream_limit_bytes':1048576,'stream_truncated':{k:False for k in streams}} + active=base/('launcher-'+mode+'.active.json') + with active.open('xb') as stream:stream.write((json.dumps({'native_context':native,'role':mode,'argv':argv,'state':'SPAWNING'},sort_keys=True)+'\n').encode()) + proc=None;selector=selectors.DefaultSelector();started=time.monotonic_ns();end=time.monotonic()+(900 if mode=='main' else 210) + try: + proc=subprocess.Popen(argv,stdin=subprocess.DEVNULL,stdout=subprocess.PIPE,stderr=subprocess.PIPE,start_new_session=True);record['process_created']=True + for pipe,label in ((proc.stdout,'stdout'),(proc.stderr,'stderr')): + os.set_blocking(pipe.fileno(),False);selector.register(pipe,selectors.EVENT_READ,label) + while selector.get_map(): + if time.monotonic()>=end:record['timeout']=True;raise TimeoutError('trusted controller time cap') + for key,_ in selector.select(min(0.2,max(0,end-time.monotonic()))): + part=os.read(key.fileobj.fileno(),65536) + if not part:selector.unregister(key.fileobj);key.fileobj.close();continue + room=1048576-sizes[key.data];kept=part[:room];streams[key.data].write(kept);digests[key.data].update(kept);sizes[key.data]+=len(kept) + if len(part)>room:record['stream_truncated'][key.data]=True;raise ValueError('trusted controller stream exceeded one MiB') + record['exit_code']=proc.wait(timeout=max(0.01,end-time.monotonic()));record['complete']=True + except BaseException as exc:record['error']=type(exc).__name__ + finally: + if proc is not None and proc.poll() is None: + for sig,grace in ((signal.SIGTERM,4),(signal.SIGKILL,1)): + if proc.poll() is not None:break + try:os.killpg(proc.pid,sig);proc.wait(timeout=grace) + except (ProcessLookupError,subprocess.TimeoutExpired):pass + except BaseException as exc:record['termination_errors'].append(type(exc).__name__) + record['process_unreaped']=proc.poll() is None + if proc is not None: + record['exit_code']=proc.returncode + for pipe in (proc.stdout,proc.stderr): + try: + if pipe is not None and not pipe.closed:pipe.close() + except BaseException as exc:record['termination_errors'].append('PIPE:'+type(exc).__name__) + try:selector.close() + except BaseException as exc:record['termination_errors'].append('SELECTOR:'+type(exc).__name__) + for stream in streams.values(): + try:stream.flush();os.fsync(stream.fileno());stream.close() + except BaseException as exc:record['termination_errors'].append('STREAM:'+type(exc).__name__) + if record['process_unreaped'] or record['termination_errors']:record['complete']=False + record['captured_stream_bytes']=sizes;record['duration_ns']=time.monotonic_ns()-started + record['streams']={k:{'path':prefix+'.'+k,'bytes':sizes[k],'sha256':digests[k].hexdigest(),'complete':record['complete'] and not record['stream_truncated'][k]} for k in streams} + status=(json.dumps(record,sort_keys=True)+'\n').encode() + if len(status)>65536:raise ValueError('launcher terminal metadata exceeded reserved64KiB') + with (base/(prefix+'.status.json')).open('xb') as stream:stream.write(status);stream.flush();os.fsync(stream.fileno()) + if proc is not None and proc.poll() is not None and not record['termination_errors']:active.unlink() + raise SystemExit(0 if record['complete'] and not record['process_unreaped'] and record['exit_code']==0 else 1) + PY + - name: Seal both launcher terminals and every bounded original after owned absence + id: final_seal + if: always() + timeout-minutes: 2 + run: | + set -euo pipefail + python3 -I -B -S - <<'PY' + import hashlib,json,math,os,pathlib,re,selectors,signal,stat,subprocess,time + MIB=2**20 + native={key:os.environ[name] for key,name in (('repository','GITHUB_REPOSITORY'),('checked_commit','GITHUB_SHA'),('run_id','GITHUB_RUN_ID'),('run_attempt','GITHUB_RUN_ATTEMPT'))} + temporary=pathlib.Path(os.environ['FORMAL_EVIDENCE_TEMP']);volume=temporary.parent;base=temporary/('formal-regression-'+native['run_id']+'-'+native['run_attempt']) + final=base/'final-publish';errors=[];missing=[];partial=[];refused=[];rows=[];total=0;statuses={};writers_absent=False;prep_bytes=0;prep_count=0 + budget_root=temporary/('formal-regression-budget-'+native['run_id']+'-'+native['run_attempt']) + def require(value,message): + if not value:raise ValueError(message) + def sha(raw):return hashlib.sha256(raw).hexdigest() + def encoded(value):return (json.dumps(value,sort_keys=True,allow_nan=False)+'\n').encode() + def strict(raw): + def pairs(items): + value={} + for k,v in items: + require(k not in value,'duplicate final-seal JSON key');value[k]=v + return value + def reject(v):raise ValueError('nonfinite final-seal JSON') + def finite(v): + n=float(v);require(math.isfinite(n),'nonfinite final-seal number');return n + return json.loads(raw,object_pairs_hook=pairs,parse_constant=reject,parse_float=finite) + def read(path,limit=4*MIB): + path=pathlib.Path(path);require(path.is_absolute(),'absolute original path');parent=os.open(path.anchor,os.O_RDONLY|os.O_DIRECTORY|os.O_NOFOLLOW);leaf=None + try: + for part in path.parts[1:-1]: + child=os.open(part,os.O_RDONLY|os.O_DIRECTORY|os.O_NOFOLLOW,dir_fd=parent);os.close(parent);parent=child + leaf=os.open(path.name,os.O_RDONLY|os.O_NOFOLLOW|os.O_NONBLOCK,dir_fd=parent);before=os.fstat(leaf) + require(stat.S_ISREG(before.st_mode) and before.st_nlink==1 and before.st_uid==os.getuid() and before.st_size<=limit,'owned regular bounded original') + raw=b'' + while len(raw)<=limit: + part=os.read(leaf,min(65536,limit+1-len(raw))) + if not part:break + raw+=part + after=os.fstat(leaf);require((before.st_dev,before.st_ino,before.st_size,before.st_mtime_ns,before.st_ctime_ns)==(after.st_dev,after.st_ino,after.st_size,after.st_mtime_ns,after.st_ctime_ns) and len(raw)==before.st_size,'original changed during final read') + return raw + finally: + if leaf is not None:os.close(leaf) + os.close(parent) + def directory(path): + info=path.lstat();require(stat.S_ISDIR(info.st_mode) and info.st_uid==os.getuid() and stat.S_IMODE(info.st_mode)==0o700,'owned closed staging directory') + def reserve(size,count=1): + require(type(size) is int and size>=0 and prep_bytes+total+size+8*MIB<=64*MIB and prep_count+len(rows)+count+8<=1024,'single retained/decompressed/member budget including raw-ZIP reserve') + def write(name,raw,role,limit=MIB): + global total + require(re.fullmatch(r'[A-Za-z0-9_.-]+',name) and len(raw)<=limit and name not in {v['path'] for v in rows},'closed final member name/limit') + reserve(len(raw));fd=os.open(final/name,os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,0o600) + with os.fdopen(fd,'wb') as stream:stream.write(raw);stream.flush();os.fsync(stream.fileno()) + total+=len(raw);rows.append({'path':name,'bytes':len(raw),'sha256':sha(raw),'role':role}) + def move_original(path,name,raw,role): + global total + require(name not in {v['path'] for v in rows},'duplicate final member');reserve(len(raw)) + # Same-filesystem rename conserves the original bytes and bounds transient storage; no hard links or content regeneration. + os.rename(path,final/name);require(read(final/name)==raw,'renamed original byte join') + total+=len(raw);rows.append({'path':name,'bytes':len(raw),'sha256':sha(raw),'role':role,'conserved_from':path.parent.name+'/'+path.name}) + def native_command(argv): + proc=None;sel=selectors.DefaultSelector();buffers={'stdout':bytearray(),'stderr':bytearray()};record={'argv':argv,'complete':False,'exit_code':None,'error':None,'process_unreaped':False,'termination_errors':[]};end=time.monotonic()+20 + try: + proc=subprocess.Popen(argv,stdin=subprocess.DEVNULL,stdout=subprocess.PIPE,stderr=subprocess.PIPE,start_new_session=True, + env={'PATH':'/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin','LANG':'C.UTF-8','TZ':'UTC','DOCKER_CONFIG':str(base/'client')}) + for stream,name in ((proc.stdout,'stdout'),(proc.stderr,'stderr')):os.set_blocking(stream.fileno(),False);sel.register(stream,selectors.EVENT_READ,name) + while sel.get_map(): + if time.monotonic()>=end:raise TimeoutError('final native absence probe timeout') + for key,_ in sel.select(min(0.2,max(0,end-time.monotonic()))): + part=os.read(key.fileobj.fileno(),65536) + if not part:sel.unregister(key.fileobj);key.fileobj.close();continue + room=65536-len(buffers[key.data]);buffers[key.data].extend(part[:room]);require(len(part)<=room,'final native absence original exceeded64KiB') + record['exit_code']=proc.wait(timeout=max(0.01,end-time.monotonic()));record['complete']=True + except BaseException as exc:record['error']=type(exc).__name__ + finally: + if proc is not None and proc.poll() is None: + for sig,grace in ((signal.SIGTERM,4),(signal.SIGKILL,1)): + if proc.poll() is not None:break + try:os.killpg(proc.pid,sig);proc.wait(timeout=grace) + except (ProcessLookupError,subprocess.TimeoutExpired):pass + except BaseException as exc:record['termination_errors'].append(type(exc).__name__) + record['process_unreaped']=proc.poll() is None + if proc is not None: + record['exit_code']=proc.returncode + for stream in (proc.stdout,proc.stderr): + if stream is not None and not stream.closed:stream.close() + sel.close() + if record['process_unreaped'] or record['termination_errors']:record['complete']=False + return record,{k:bytes(v) for k,v in buffers.items()} + def fallback(reason): + global final + # Outside the63MiB volume only bootstrap/fallback originals are allowed, with a combined1MiB physical ceiling. + volume.mkdir(mode=0o700,exist_ok=True);directory(volume) + cookie=volume/'storage-native-context.json' + if cookie.exists():require(strict(read(cookie,65536))=={'schema_version':1,'native_context':native},'actual owned storage context') + else: + require(not (volume/'retained.img').exists() and not os.path.ismount(temporary),'unbound existing storage cannot be adopted') + with cookie.open('xb') as stream:stream.write(encoded({'schema_version':1,'native_context':native})) + target=volume/'fallback';target.mkdir(mode=0o700,exist_ok=True);final=target + prior=read(volume/'storage-bootstrap.json',900000) if (volume/'storage-bootstrap.json').exists() else b'' + outside_context=read(cookie,65536) + payload=encoded({'schema_version':1,'native_context':native,'status':'HOLD','reason':reason,'errors':errors,'missing':missing[:64],'partial':partial[:64],'refused':refused[:64], + 'owned_writers_absent':False,'originals_complete':False,'runtime':'UNQUALIFIED','raw_native_archive_fit':'UNKNOWN','scientific_effect':'NONE'}) + require(len(payload)<=65536 and len(prior)+len(payload)+len(outside_context)<=MIB,'outside bootstrap/fallback physical bound') + path=target/'terminal-hold.json';fd=os.open(path,os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,0o600) + with os.fdopen(fd,'wb') as stream:stream.write(payload);stream.flush();os.fsync(stream.fileno()) + index=encoded({'schema_version':1,'native_context':native,'status':'HOLD_INCOMPLETE','members':[{'path':'terminal-hold.json','bytes':len(payload),'sha256':sha(payload)}], + 'self_exclusion':'fallback-manifest.json only','other_originals':'UNAVAILABLE_OR_REFUSED; NO_COMPLETENESS_CLAIM'}) + require(len(index)<=32768 and len(prior)+len(payload)+len(index)+len(outside_context)<=MIB,'outside fallback closed inventory capacity') + with (target/'fallback-manifest.json').open('xb') as stream:stream.write(index);stream.flush();os.fsync(stream.fileno()) + require({p.name for p in target.iterdir()}=={'terminal-hold.json','fallback-manifest.json'},'closed fallback upload membership') + try: + directory(temporary);directory(base) + storage=strict(read(temporary/'storage-capacity.json',65536));policy_raw=read(budget_root/'policy.json',65536);policy=strict(policy_raw) + account_raw=read(budget_root/'preparation-account.json',MIB);account=strict(account_raw) + require(storage['native_context']==policy['native_context']==account['native_context']==native and policy['total_retained_decompressed_bytes']==64*MIB and policy['total_members']==1024 + and policy['metadata_response_bytes']==4*MIB and policy['raw_native_archives_reserved_bytes']==4*MIB and account['policy_sha256']==sha(policy_raw),'current shared policy/preparation identity') + capacity=os.statvfs(temporary);physical=capacity.f_frsize*capacity.f_blocks + require(os.path.ismount(temporary) and 0256000 or used+len(raw)>MIB: + capture_complete=False;return + flags=os.O_WRONLY|os.O_CREAT|os.O_NOFOLLOW + fd=os.open(record_path,flags,0o600) + info=os.fstat(fd);require(stat.S_ISREG(info.st_mode) and info.st_nlink==1 and info.st_uid==os.getuid(),'owned cleanup metadata writer') + os.ftruncate(fd,0) + with os.fdopen(fd,'wb') as stream:stream.write(raw);stream.flush();os.fsync(stream.fileno()) + def command(argv,allow_absent=False): + proc=None;sel=selectors.DefaultSelector();buffers={'stdout':bytearray(),'stderr':bytearray()};r={'argv':argv,'complete':False,'exit_code':None,'process_unreaped':False,'error':None};end=time.monotonic()+20 + try: + proc=subprocess.Popen(argv,stdin=subprocess.DEVNULL,stdout=subprocess.PIPE,stderr=subprocess.PIPE,start_new_session=True, + env={'PATH':'/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin','LANG':'C.UTF-8','TZ':'UTC','DOCKER_CONFIG':str(base/'client')}) + for stream,name in ((proc.stdout,'stdout'),(proc.stderr,'stderr')):os.set_blocking(stream.fileno(),False);sel.register(stream,selectors.EVENT_READ,name) + while sel.get_map(): + if time.monotonic()>=end:raise TimeoutError('owned storage cleanup native timeout') + for key,_ in sel.select(min(0.2,max(0,end-time.monotonic()))): + part=os.read(key.fileobj.fileno(),32768) + if not part:sel.unregister(key.fileobj);key.fileobj.close();continue + room=32768-len(buffers[key.data]);buffers[key.data].extend(part[:room]);require(len(part)<=room,'bounded storage cleanup raw stream') + r['exit_code']=proc.wait(timeout=max(0.01,end-time.monotonic()));r['complete']=True + except BaseException as exc:r['error']=type(exc).__name__ + finally: + if proc is not None and proc.poll() is None: + for sig,grace in ((signal.SIGTERM,4),(signal.SIGKILL,1)): + if proc.poll() is not None:break + try:os.killpg(proc.pid,sig);proc.wait(timeout=grace) + except (ProcessLookupError,subprocess.TimeoutExpired):pass + r['process_unreaped']=proc.poll() is None + if proc is not None: + r['exit_code']=proc.returncode + for stream in (proc.stdout,proc.stderr): + if stream is not None and not stream.closed:stream.close() + sel.close();r['streams']={k:{'raw_base64':base64.b64encode(v).decode(),'bytes':len(v),'partial':not r['complete']} for k,v in buffers.items()};records.append(r);preserve() + require(r['complete'] and not r['process_unreaped'] and r['exit_code'] in ((0,1) if allow_absent else (0,)),'owned cleanup native result unavailable') + return bytes(buffers['stdout']) + try: + require(not any((base/n).exists() for n in ('active-command.json','launcher-main.active.json','launcher-recovery.active.json')),'unresolved owned writer prevents storage release') + for role,prefix in (('main','control-process'),('recovery','recovery-process')): + choices=[base/'final-publish'/(prefix+'.status.json'),base/(prefix+'.status.json')];path=next((p for p in choices if p.exists()),None) + require(path is not None,'actual launcher terminal required for storage release');status=json.loads(read(path,65536)) + require(status['native_context']==native and status['role']==role and status['process_created'] is True and status['process_unreaped'] is False and not status['termination_errors'],'actual launcher child reaped before storage release') + raw=command(['docker','ps','--all','--no-trunc','--filter','label=org.formal-controls.run-id='+native['run_id'],'--filter','label=org.formal-controls.attempt='+native['run_attempt'],'--format','{{json .}}']) + require(raw==b'','owned worker remains before storage release') + for target,backing,size in ((base/'output',volume/'worker-output.img',64*MIB),(temporary,volume/'retained.img',63*MIB)): + raw=command(['findmnt','--json','--mountpoint',str(target)],allow_absent=True);data=json.loads(raw) if raw.strip() else {'filesystems':[]};mounts=data.get('filesystems',[]) + require(len(mounts)<=1,'ambiguous owned mount') + if mounts: + require(mounts[0]['target']==str(target) and mounts[0].get('fstype')=='ext4','owned mount native identity') + loop=str(mounts[0]['source']).split('[')[0];actual=command(['losetup','--noheadings','--output','BACK-FILE',loop]).decode().strip() + info=backing.lstat();require(actual==str(backing) and stat.S_ISREG(info.st_mode) and info.st_nlink==1 and info.st_uid==os.getuid() and info.st_size==size,'owned loop backing/type/size') + command(['sudo','-n','umount',str(target)]) + preserve() + except BaseException as exc:errors.append({'type':type(exc).__name__,'reason':'OWNED_STORAGE_RELEASE_UNCONFIRMED'});preserve() + summary={'schema_version':1,'native_context':native,'records':records,'errors':errors,'captured_originals_complete':capture_complete, + 'native_job_log_original_readback':'REQUIRED; NO EARLIER_ARTIFACT_REBINDING','runtime_custody':'UNKNOWN','scientific_effect':'NONE'} + print(json.dumps(summary,sort_keys=True)) + raise SystemExit(0 if not errors and capture_complete else 1) + PY + - name: Record native upload identity without claiming original readback + if: always() + timeout-minutes: 1 + env: + ARTIFACT_ID: ${{ steps.retained.outputs.artifact-id }} + ARTIFACT_DIGEST: ${{ steps.retained.outputs.artifact-digest }} + run: | + python3 -I -B -S - <<'PY' + import json,os,re + identity=os.environ.get('ARTIFACT_ID','');digest=os.environ.get('ARTIFACT_DIGEST','') + if not re.fullmatch('[1-9][0-9]*',identity) or not re.fullmatch('(?:sha256:)?[0-9a-f]{64}',digest): + raise ValueError('native control artifact identity unavailable') + print(json.dumps({'artifact_id':identity,'artifact_digest':digest,'run_id':os.environ['GITHUB_RUN_ID'], + 'run_attempt':os.environ['GITHUB_RUN_ATTEMPT'],'raw_archive_and_member_readback':'REQUIRED_AFTER_JOB', + 'custody_authentication':'UNKNOWN','scientific_effect':'NONE'})) + PY diff --git a/architecture/formal_regression.py b/architecture/formal_regression.py new file mode 100644 index 000000000..63a85dce4 --- /dev/null +++ b/architecture/formal_regression.py @@ -0,0 +1,33 @@ +"""Importable ABI scaffold for independent hosted assertion-RED controls. + +This deliberately implements none of the accepted collector/core behavior. +A literal empty result is not admission, native evidence or a successful core. +Working code may follow only qualified hosted RED and distinct technical review. +""" +Record = dict[str, object] +RequestContext = Record +Policy = Record +TargetStatement = Record +InventoryResult = Record + + +def decode_request(raw: bytes) -> RequestContext: + return {} + + +def decode_policy(raw: bytes, expected_sha256: str) -> Policy: + return {} + + +def request_key(context: RequestContext) -> str: + return "" + + +def content_inventory(records: list[TargetStatement], policy: Policy, + membership: Record, acceptances: Record) -> InventoryResult: + return {"core": None, "formal_inventory_sha256": None, + "diagnostic_inventory_sha256": None, "issues": []} + + +def inventory_sha256(core: Record) -> str: + return "" diff --git a/docs/architecture/formal-regression-contract.json b/docs/architecture/formal-regression-contract.json new file mode 100644 index 000000000..7388315bc --- /dev/null +++ b/docs/architecture/formal-regression-contract.json @@ -0,0 +1,563 @@ +{ + "assurance_labels": { + "all8": "ACTIVE_UNMET", + "authentic_real_collector": "NOT_IMPLEMENTED_OR_OBSERVED", + "enforcement": "NOT_ACTIVATED_OR_PROVEN", + "future_role": "NONE_RESERVED", + "mapping": "UNKNOWN_ABSENT", + "native_runtime": "NOT_RUN", + "organization": 0, + "scientific_effect": "NONE", + "scientific_status_authority": false, + "semantic_review": "NONE_PERFORMED", + "source": "R01_DRAFT_DESIGN_ONLY; prior whole review REQUEST_CHANGES/R1; fresh whole review PENDING" + }, + "author": "/root/req8_inventory_contract_revision_0133", + "closed_types": { + "Acquisition": [ + "acquisition_id", + "event_identity", + "request_key", + "started_at", + "finished_at", + "native_observations", + "evidence_revision", + "terminal_reason", + "producing_native_context", + "bundle_artifact_ref" + ], + "AuthorityAcceptance": [ + "record_ref", + "native_acceptance_ref", + "accepted_bytes_sha256", + "accepted_request_key", + "actor_identity", + "accepted_lineage", + "scope", + "observed_version" + ], + "BindingManifest": [ + "schema_version", + "domain_id", + "graph_selector", + "node_coverage", + "target_coverage", + "links" + ], + "Bundle": [ + "schema_version", + "request_context", + "request_key", + "acquisition", + "control_policy_refs", + "member_index", + "native_observations", + "source_membership", + "mapping_and_acceptances", + "coverage", + "base_inventory", + "candidate_inventory", + "adapter_projections", + "semantic_impact", + "evidence_loss_impact", + "review_originals", + "revalidations_and_acceptances", + "graph_descriptor", + "preservation", + "issues" + ], + "CommitRef": [ + "repository", + "commit", + "tree" + ], + "CoverageRow": [ + "subject", + "state", + "link_ids", + "scope_evidence" + ], + "CoverageRow_states": [ + "LINKED", + "OUTSIDE_ACCEPTED_DOMAIN", + "UNRESOLVED" + ], + "Decision": [ + "schema_version", + "request_key", + "bundle_sha256", + "control_policy_refs", + "fresh_context_capture_refs", + "source_verdict", + "native_runtime_verdict", + "collector_custody_verdict", + "review_custody_verdict", + "preservation_verdict", + "enforcement_scope", + "decision", + "reasons", + "scientific_effect", + "scientific_status_authority" + ], + "Decision_values": [ + "PASS", + "FAIL", + "UNRESOLVED", + "SUPERSEDED" + ], + "EvidenceLossFingerprint": [ + "native_record_identity", + "source_availability", + "positive_execution_availability", + "attempt_custody", + "reasons" + ], + "GraphDescriptor": [ + "carrier_graph_ref", + "upstream_provenance_ref", + "gate_sha256", + "exporter_source_refs", + "graph_artifact_ref", + "graph_sha256", + "regression_report_sha256" + ], + "GraphDescriptor_rule": "Same exact original validated graph export is handed to future SSG; derived hold-marked graph clones never replace original graph source. Current SSG consumption remains unfinished.", + "Link": [ + "id", + "node", + "format", + "native_repository", + "package", + "target", + "module", + "informal_origin", + "informal_statement_slice", + "informal_proof_slice", + "formal_declaration_slice", + "formal_proof_slice", + "original_alignment_refs" + ], + "NativeContext_event_rule": "Requested checkedK and actual native event/control SHA are separate host observations. Do not inject environment strings to claim the unchanged current required binder authenticated a different checkout. Supervisor adaptation/source/runtime qualification is required.", + "NativeObservation": [ + "id", + "primitive", + "request_identity", + "principal_scope_label", + "acquired_at", + "raw_response_member", + "response_bytes", + "response_sha256", + "completeness", + "source_membership", + "issues" + ], + "NativeProducerPolicy": [ + "format", + "workflow_source_ref", + "supervisor_source_refs", + "runtime_identity", + "toolchain", + "dependency_policy", + "source_control_files", + "print_options", + "artifact_inventory_contract", + "attempt_custody_contract", + "sandbox_contract" + ], + "NodeSemanticFingerprint": [ + "mapping_state", + "accepted_links", + "native_target_content", + "scope_contracts", + "source_slice_content" + ], + "OriginalGroup": [ + "original_alignment_ref", + "all_surviving_uses", + "successor_coverage", + "unresolved_uses" + ], + "Policy": [ + "schema_version", + "repositories", + "protected_domains", + "graph_sources", + "trusted_control_sources", + "gate_sha256", + "native_producer_policies", + "mapping_authorities", + "review_authorities", + "publisher", + "preservation", + "disclosure", + "limits", + "enforcement" + ], + "PublisherPolicy": [ + "native_app_id", + "installation_id", + "check_name", + "status_subject", + "required_permissions", + "control_source_refs" + ], + "RawMember": [ + "id", + "member_path", + "bytes", + "sha256", + "role", + "native_ref" + ], + "RequestContext": [ + "schema_version", + "repository", + "pull_request", + "base_ref", + "base", + "head_ref", + "head", + "checked_merge", + "checked_merge_parents", + "merge_mode", + "control", + "policy_sha256" + ], + "RequestContext_types": { + "base": "CommitRefB", + "checked_merge": "CommitRefS in target repository", + "control": "CommitRefT, future independently admitted implementation revision", + "head": "CommitRefH, possibly fork repository", + "merge_mode": "service_merge only for blocking mode; native parent semantics qualified first" + }, + "Revalidation": [ + "schema_version", + "request_key", + "new_graph_ref", + "mapping_sha256", + "formal_inventory_sha256", + "candidate_manifest_scope_refs", + "original_groups", + "successor_review_refs", + "evidence_refs", + "disposition", + "lineage" + ], + "SnapshotSelector": [ + "side", + "path", + "git_blob", + "sha256", + "bytes" + ], + "SnapshotSelector_side": "base resolves B;candidate resolves S; repository derives from those exact native CommitRefs. ExternalSourceSelector is {side:origin,ref:existing-six-field-GitRef}. No guessed commit.", + "TargetSemanticContent": [ + "format", + "native_repository", + "package", + "target", + "module_content_identity", + "type_content_sha256", + "type_content_bytes", + "compiler_dependency_options_identity", + "accepted_formal_statement_selector", + "accepted_formal_proof_selector", + "manifest_contract_sha256", + "scope_content_identity", + "unresolved_fields" + ], + "TargetStatement": [ + "format", + "target", + "manifest_ref", + "scope_ref", + "module_ref", + "origin_ref", + "checked_local_copy_ref", + "type_record", + "declaration_slice", + "proof_slice", + "compiler_context", + "native_context", + "availability", + "issues" + ], + "acquisition_provenance_rule": "Verifier authenticates bundle producer against admitted workflow/control/job/attempt and native artifact identity. A serialized principal/scope label, supplied archive or self-consistent inventory is insufficient. No qualifying capture provenance means UNRESOLVED.", + "authority_rule": "Acceptance is native-authenticated under independently admitted authority policy, not a self-asserted candidate field. GitHub actor does not cryptographically establish provider/family/agent. Preserve actual evidence/exposure/org0 and unresolved attribution.", + "compiler_context": [ + "toolchain", + "compiler_identity", + "options", + "dependency_revisions", + "dependency_lock_ref", + "producer_source_refs", + "runtime_identity" + ], + "evidence_loss_rule": "Execution loss has separate derived node/native-axis impact and fails gate when required. It does not alone seed affected semantic review refs or stale accepted alignment. Source/statement/scope join loss can independently seed semantic revalidation.", + "inventory_digest": "formal_inventory_sha256 = lowercase_hex(SHA256(CanonicalASCII(InventoryCore))). CanonicalASCII is precisely lexical_rules.json: sorted object keys, compact separators, ensure_ascii=true, no nonfinite values, ASCII bytes and NO trailing newline. No prefix/suffix, extra digest wrapper or raw TargetStatement is hashed.", + "link_rules": "No added native manifest fields. Unknown origin/slices are null, not fabricated. Main/Math format-specific lookups unchanged. Authority acceptance is separate from candidate BindingManifest and binds fully resolved selectors/graph/scope/domain. Coverage exhausts actual admitted nodes/targets; many-to-many links explicit/unique.", + "native_context": [ + "repository", + "checked_commit", + "run_head_sha", + "workflow_identity", + "workflow_source_ref", + "job_id", + "run_id", + "run_attempt", + "purpose", + "conclusion", + "supervisor_capture_ref" + ], + "request_key": "SHA256(canonical({domain:formal-regression-request/v1,context:RequestContext})); excludes acquisition/event IDs,timestamps,evidence revision. This prevents detached-review/recollection circularity.", + "revalidation_authority": "Native acceptance outside candidate content binds exact immutable detached record, context and declared lineage. Existing native whole-manifest alignment and6112554711 annotations still independently validate. No collector semantic review or organization-independence claim.", + "semantic_projection_rule": "Every actual graph node has one row; native targets/links sorted by exact canonical identity. Compare content/scoped selectors, preserve full raw GitRefs separately. Paired same-blob source commit advance normalizes only under adapter rule; external origin changes do not normalize. Unscoped module changes are explicit. Do not include volatile run IDs/timestamps as statement content.", + "source_membership": "Distinct native-service assertion of repo/commit/tree/path/mode/blob plus local byte/blob/tree reconstruction result. Raw signed commit hash reconstruction claimed only when actual raw serialization is available. No authentication Boolean supplied by candidate is trusted.", + "type_record": "{log_ref:existing RunRef,slice:existing Slice}; verified raw whole log retained. Lossless NAME-header/indented continuation record, exactly one per actual native target. Null/ambiguous/missing record cannot PASS." + }, + "concrete_missing_inputs": [ + { + "current": "ABSENT;31SIDE24targets/49node carrier do not supply typed links", + "id": "M1", + "input": "Accepted complete resolved mapping/coverage manifest", + "required_evidence": "Exact native authority acceptance of graph/target/source/slices/domain and immutable manifest refs." + }, + { + "current": "UNKNOWN/NOT_SUPPLIED", + "id": "M2", + "input": "Real original review and revalidation authority", + "required_evidence": "Original GitRefs, authenticated immutable review/evidence plus accepted lineage and detached successor context." + }, + { + "current": "NOT_IMPLEMENTED_OR_ADMITTED", + "id": "M3", + "input": "Effective trusted controller/producer/runtime release", + "required_evidence": "Reviewed exact T/P/workflow/dependency/runtime pins, hostile candidate boundary/source/execution/custody controls." + }, + { + "current": "NOT_ESTABLISHED_BY_AGENT_GET_CAPABILITY", + "id": "M4", + "input": "CI-native authenticated/attempt-specific transport", + "required_evidence": "Actual immutable object/run/job/artifact/supervisor joins, current attempt disambiguation and one bounded original read." + }, + { + "current": "NOT_ADMITTED_FOR_THIS_COLLECTOR", + "id": "M5", + "input": "Private preservation/governing custody route", + "required_evidence": "Carrier access/disclosure qualification, original archive/member readback and actual retention/transfer record." + }, + { + "current": "NO_NEW_APP_OR_PERMISSION_OR_RULES_CONFIGURED", + "id": "M6", + "input": "Publisher installation and protected final-write enforcement", + "required_evidence": "Real installation/check identity, least permissions, fresh rule readback, wrong-app/missing/stale-base rejection and admitted write-boundary fresh consumption; unconstrained routes explicit." + }, + { + "current": "NOT_SUPPLIED_OR_EXECUTED", + "id": "M7", + "input": "Held-out real transition and actual semantic revalidation", + "required_evidence": "Real B/S sources/types, authoritative link, original downstream review, real changed statement/premise and nonauthor accepted revalidation; calibrated proof/unscoped/deleted-edge cases; exact preserved protected result." + } + ], + "formal_inventory_hash_contract": { + "TargetSemanticContent_fields": { + "accepted_formal_proof_selector": "same closed SelectorEntry array rule for accepted proof slices", + "accepted_formal_statement_selector": "complete SelectorEntry array from native-authenticated accepted mapping links for this target, resolved against actual candidate module bytes", + "compiler_dependency_options_identity": "CompilerDependencyOptionsContent projected from actual qualified compiler_context and NativeProducerPolicy print/build/runtime records, never from policy expectations alone", + "format": "exact main-formal-gate/v1 or math-formal-gate/v1 from admitted original native format", + "manifest_contract_sha256": "SHA256 of exact original raw candidate native manifest bytes at TargetStatement.manifest_ref; no field omission/reformatting or replacement native format", + "module_content_identity": "SourceContent projected from qualified candidate TargetStatement.module_ref, after actual native target-to-module resolution", + "native_repository": "exact repository of native candidate source at S; not log/artifact repository inferred from its name", + "package": "SourcePackageIdentity projected from original native candidate manifest", + "scope_content_identity": "ScopeContent projected from actual candidate scope_ref and complete resolved scope/import membership records", + "target": "exact native target name, existing NAME grammar; no title substitution", + "type_content_bytes": "exact end_byte-start_byte of that whole target record", + "type_content_sha256": "SHA256 of the exact lossless whole target record bytes selected by TargetStatement.type_record.slice from its original elaborated-types.log, including header/indentation/line endings, no stripping/reformatting; log_ref, log offsets and other records are NOT hashed here", + "unresolved_fields": "sorted unique array of unresolved field NAMES from this exact TargetSemanticContent schema; no volatile error strings/IDs/timestamps. Identity fields cannot be unresolved inside a core." + }, + "change_and_selector_rules": [ + "Inventory digest is a byte/source-context binding, not the formal-impact predicate. Snapshot commit IDs alone are outside SourceContent only under the declared snapshot role; immutable origin commits and dependency revisions remain in content. Keep full refs/membership separately and retain current adapter paired-snapshot normalization exactly, not for origins.", + "Comparable changed type-record bytes classify formal_statement_changed. Actual compiler/options/print/dependency/runtime context change classifies comparison_unknown plus revalidation even with equal type bytes. Scope/import or raw manifest contract change also seeds revalidation. Source/selector content changes alter inventory digest; no semantic equivalence is inferred.", + "A module edit can be proof_body_changed only with actual accepted declaration AND proof selectors on both sides, equal declaration-slice bytes and target-type bytes/context, and equality of the two whole module byte strings after removing the complete accepted proof intervals (sort intervals by start; nonoverlap required). This is a conservative source classification, not proof validity or alignment acceptance. All other target declarations/uses and imported context must remain accounted for.", + "The exact changed proof bytes/module/slice identities still change this inventory digest. A required manifest refresh or scope/dependency delta adds its independent revalidation reason and is never suppressed by proof_body_changed. The current raw-manifest binding is deliberately conservative.", + "Selector-only change (including offset change, addition or known absence/loss) changes selector content/digest and classifies formal_selector_changed; it never alone asserts changed printed type or failed/stale kernel. An actual module edit with either accepted declaration/proof selector absent or unqualified remains formal_source_changed_unscoped, never guessed proof-only. Unknown acceptance/source join also preserves unresolved coverage.", + "Execution-only failure/loss is evidence_loss_impact, not a semantic type delta. A missing newly collected type yields an unresolved diagnostic inventory, not formal_statement_changed by null comparison. Source/type/scope join loss can separately require semantic revalidation under the existing conservative policy. Preserve all original groups and separate union impact rules." + ], + "closed_value_types": { + "ByteContent": { + "bytes": "exact nonnegative integer, not Boolean", + "sha256": "SHA256 of exactly those retained raw bytes; lowercase64hex" + }, + "CompilerDependencyOptionsContent": { + "build_config": "SourceContent array of complete admitted build-control input set, not only changed files", + "compiler_identity": { + "executable": "ByteContent of actual compiler binary", + "version_output": "ByteContent of exact raw compiler-version output" + }, + "dependencies": "DependencyContent array sorted by CanonicalASCII(name), unique names, exact equality to actual native manifest AND dependency lock", + "dependency_lock": "SourceContent for exact actual lock bytes", + "options": "ordered array of exact effective compiler semantic-option strings, as emitted by admitted producer/supervisor schema; never a guessed filter of raw argv", + "print_options": "ordered array of exact admitted and observed type-print option strings", + "producer_sources": "SourceContent array of all effective admitted producer/supervisor source inputs; retained fixed origins", + "runtime_identity": "RuntimeContent; runtime instance/host/time/run IDs excluded", + "toolchain": "exact native toolchain string" + }, + "DependencyContent": { + "name": "exact native locked dependency name", + "revision": "exact native locked full lowercase40hex revision" + }, + "NamedExecutableContent": { + "content": "ByteContent of the actual supervisor-observed executable", + "name": "exact nonempty admitted logical executable name" + }, + "RuntimeContent": { + "executables": "nonempty NamedExecutableContent array sorted by CanonicalASCII(name); duplicate names refuse", + "image_manifest": "ByteContent of actual immutable image-manifest bytes, or null ONLY for an admitted non-image runtime", + "platform": "exact immutable admitted platform identifier" + }, + "ScopeContent": { + "import_files": "SourceContent array of the complete resolved direct/transitive imported source inputs relevant to this target, excluding this target module itself; neither an empty guess nor a graph-title-derived import set", + "scope_files": "nonempty SourceContent array of exact scope_ref plus every additional scope-contract input required by admitted native policy" + }, + "SelectorContent": { + "end_byte": "exact integer >start_byte and <=source bytes", + "sha256": "SHA256(raw_source_bytes[start_byte:end_byte])", + "source": "resolved SourceContent of the actual selected formal module", + "start_byte": "exact integer >=0" + }, + "SelectorEntry": { + "link_id": "exact accepted Link.id for this native target", + "selector": "SelectorContent or null for explicitly absent formal selector on that accepted link" + }, + "SelectorEntry_array_order": "Sort by CanonicalASCII(link_id), unique link IDs. Both selector arrays enumerate the identical complete accepted-link ID set for this native target. Empty ONLY for an actual zero-link set; unresolved mapping still fails separate coverage. Supplied nonnull selectors require native authority acceptance and actual slice verification; loss of acceptance cannot be encoded as harmless known absence.", + "SourceContent_array_order": "For build_config,producer_sources,scope_files,import_files sort by CanonicalASCII([repository,path]), where origin reads repository/path from ref. Unique repository/path within each array; duplicate or conflicting source identities refuse. Empty arrays only where actual complete admitted input enumeration is empty. Repeated identities across roles must agree exactly.", + "SourceContent_origin": { + "kind": "literal origin", + "ref": "existing closed six-field GitRef {repository,commit,path,git_blob,sha256,bytes}, full immutable external/control/dependency origin retained" + }, + "SourceContent_rule": "Exactly one of these tagged forms. snapshot applies ONLY to a source proven native member of the selected side B/S snapshot in its target repository; project its existing six-field GitRef by removing commit and adding kind:snapshot. The exact omitted commit remains mandatory in source_membership/request_context/raw TargetStatement. Every external fixed origin, producer/control source at T, or dependency origin uses origin with ALL six fields, including commit. A caller cannot relabel origin as snapshot. No RunRef is a SourceContent.", + "SourceContent_snapshot": { + "bytes": "exact nonnegative integer", + "git_blob": "lowercase40hex Git blob identity verified with actual raw bytes", + "kind": "literal snapshot", + "path": "safe normalized repository-relative path", + "repository": "exact source repository", + "sha256": "lowercase64hex of raw bytes" + }, + "SourcePackageIdentity": { + "declared_name": "exact native manifest package string; null ONLY when the admitted native format has no package-name field, never a guessed title", + "manifest_path": "actual normalized repository-relative native manifest path" + } + }, + "conformance": "INVENTORY-CONFORMANCE.json contains explicitly synthetic, nonqualified byte preimages/hashes and expected classifications. They exercise this declared encoding only, not real source mapping, Lean execution, review authenticity or implementation correctness.", + "one_formula": "formal_inventory_sha256 = lowercase_hex(SHA256(CanonicalASCII(InventoryCore))). CanonicalASCII is precisely lexical_rules.json: sorted object keys, compact separators, ensure_ascii=true, no nonfinite values, ASCII bytes and NO trailing newline. No prefix/suffix, extra digest wrapper or raw TargetStatement is hashed.", + "projection_and_qualification": [ + "Resolve candidate inventory only at S from complete authenticated native manifest/target/module/scope/source membership and actual qualified original target-type records. Base uses identical rules at B for comparison. No raw TargetStatement, native_context, type_record.log_ref, capture/run/artifact/member IDs, attempt, event, acquisition, timestamp, evidence_revision or terminal message is copied into InventoryCore.", + "Project each actual target once. Read exact native format/repository/manifest/package/name, not graph labels. Derive SourceContent, type slice content, compiler/build/dependency/runtime content, accepted selectors and scope inputs by the closed forms above. Preserve source/control/compiler/runtime provenance plus ALL complete raw records in separate custody fields.", + "A required content field that is unavailable/unauthenticated/unsupported is null and its exact field name appears in unresolved_fields; a paired type hash/byte size is both null and lists both field names. Identity enumeration failure means core absent. Explicit known-absent accepted formal selectors use selector:null, not fabricated offsets. Unknown mapping/acceptance remains a separate coverage failure even if a diagnostic content core can be serialized.", + "Diagnostic partial cores may be byte-hashed as diagnostic_inventory_sha256 only. formal_inventory_sha256 is null unless enumeration is complete, every required content field has its closed qualified value and all unresolved_fields arrays are empty. A content digest alone never satisfies mapping, native positive execution, request freshness, attempt/custody, alignment authority or preservation. Known null selectors are not proof-only evidence.", + "No custody acquisition detail participates in this hash; recollection with new run/attempt/log offsets but exactly the same source and target-record bytes produces identical InventoryCore. A later acquisition never rebinds old K to S. Existing independently qualified same-S records may remain preserved; a failed new attempt does not erase them or create a new positive execution claim.", + "Collector emits the core and digest; detached Revalidation.formal_inventory_sha256 is EXACTLY this candidate digest; offline verifier independently projects the core from authenticated raw records, compares canonical core bytes and recomputes the same one formula. Null/diagnostic digests cannot be accepted in Revalidation. Reject a supplied inconsistent core/hash rather than selecting one interpretation." + ], + "revision": "R01; mandatory closed digest contract for design formal-regression-inventory/v1", + "root": { + "closed_fields": [ + "domain", + "domain_id", + "targets" + ], + "domain": "literal formal-regression-inventory/v1", + "domain_id": "exact nonempty string from independently admitted protected-domain policy, equal to the resolved BindingManifest.domain_id", + "targets": "nonempty array of exactly one TargetSemanticContent per actual native candidate target in this admitted domain, including unlinked targets. Do not subset to changed/mapped/positively executed targets." + }, + "scope": "Source-bound candidate content inventory, not semantic equivalence, a native execution receipt, review authority or a replacement for independent coverage/custody predicates.", + "target_identity_and_order": "Identity is CanonicalASCII([format,native_repository,package,target]). Sort rows by unsigned lexicographic order of these ASCII bytes. Require unique identity before sorting, including identical duplicate rows. Unsupported, incomplete or ambiguous native target enumeration yields no accepted InventoryCore/digest, never an empty/subset replacement." + }, + "interfaces": { + "admit": "At actual participating write boundary, re-consume request/report and fresh B/H/S/P/T/check identity; refusal on drift. Not an assertion of installed atomic enforcement.", + "collect": "collect(request_context, admitted_policy, native_reader) -> sealed_bundle or preserved_non_success. Only trusted process holds read credentials.", + "compare": "derive unchanged adapter reports plus separate semantic/evidence-loss impact from native-authenticated inventories; do not import candidate modules.", + "native_produce": "produce_native(requested_K, actual_native_event_context, admitted_TP, sandbox_contract) -> original native receipt/logs plus external supervisor evidence. Requested checkoutK never replaces native event/control SHA.", + "native_reader_required_primitives": [ + "read_pr_current", + "read_commit_tree_blob", + "read_attempt_jobs", + "read_artifact_identity", + "read_original_archive_once", + "read_review_and_acceptance", + "preserve_and_read_back" + ], + "publish": "publish(sealed_PASS, final_native_context, admitted_installation) -> exact native check readback at status_subjectH; no source/ref/PR edit authority.", + "verify": "verify(bundle, admitted_policy, fresh_native_context) -> sealed decision; no writer credential." + }, + "kind": "DRAFT_DECLARATIVE_CONTRACT_NOT_PRODUCT_SCHEMA_OR_CODE", + "lexical_rules": { + "identities": "Git SHA40 lowercase hex; SHA256 lowercase64hex; native IDs positive ASCII decimal strings. Paths normalized safe repository/bundle-relative, never supplied URLs. Exact nullable values preserved.", + "json": "Closed fields, duplicate/nonfinite/trailing/deep/oversized/type-coerced input refuses. Exact integer excludes Boolean. Canonical JSON is sort_keys=True,separators=(comma,colon),ensure_ascii=True,allow_nan=False, ASCII, no newline.", + "unknown": "Absent authoritative source/capability is explicit UNRESOLVED/null with reason, never inferred mapping, attempt, acceptance or PASS." + }, + "predecessor_author": "/root/native_object_conservation_1017", + "proposed_paths": [ + "architecture/formal_regression.py", + "tools/formal_regression_collect.py", + "tools/formal_regression_native.py", + "tools/formal_regression_verify.py", + "tools/formal_regression_publish.py", + ".github/workflows/formal-regression.yml", + ".github/workflows/formal-regression-native.yml", + "docs/architecture/formal-regression-policy.json", + "claims/formal-bindings.json", + "tests/test_formal_regression.py", + "tests/test_formal_regression_enforcement.py" + ], + "read_extent_notice": "All new product interfaces/types are proposed, not historical accepted ABI. Existing adapter v1 and native formats stay unchanged. Source/runtime/collector/review custody remain separate predicates.", + "regression_rules": [ + "Historical-original adapter projection retains old formal records, exact old review refs and original bytes. Candidate projection retains candidate records. Single expected native context is explicitly labeled; old/cross-repository kernel states are not globally refreshed.", + "For multiple native contexts, any extra candidate projections retain all whole-group uses; never partition one immutable original alignment group to hide a held use. Native local kernel proof and graph-source join remain separate, including unknown Math bridge.", + "Semantic fingerprints cover exactly every graph node and include authoritative mapping, formal statement/type/options/dependency content, scope/manifest contract and appropriate source selectors. Unknown nodes have explicit unknown rows and coverage cannot PASS.", + "Invoke independently pinned reverse_impact_between on actual old/new graphs and semantic snapshots; union all old/new edges. Keep returned hold clone derived. Union its semantic impacts with existing adapter regression.", + "Comparable type-byte changes are formal_statement_changed, not semantic-equivalence judgement. Changed compiler/dependency/print context is comparison_unknown plus revalidation. Missing accepted formal selectors means module change is unscoped, never guessed proof-only.", + "Execution-only failed/skipped/missing/stale/negative/attempt-unknown native evidence lowers native axis and fails required positive predicate. Separate evidence-loss impact cannot alone fabricate changed statement, stale semantic alignment or affected original review refs.", + "Select original review refs from authenticated old explicit node-target links, union downstream all-edge impact, group by all six GitRef fields, retain deleted records and surviving whole-group uses. Missing mapping/ref remains unresolved; no fabricated ID.", + "Qualified detached successor review covers every affected original group in exact candidate context; retain original stale inventory and link replacements. Fresh kernel/source is not semantic revalidation." + ], + "required_consumer_activation": { + "blocking_PASS": "Only complete authoritative coverage/custody, exact supported native contexts, genuine positive checks, all affected original-group revalidation, preserved/read-back sealed report and exact final context. No neutral/skipped/missing output succeeds.", + "bundle_trust": "Only native-authenticated admitted acquisition-job artifact is accepted; publisher verifies job/control/attempt/artifact provenance and fresh context, never trusts a candidate archive or claimed principal.", + "credential_split": "Read-only native acquisition; tokenless candidate execution; offline verifier; isolated narrow checks publisher. No contents/ref/PR/settings write authority assumed.", + "freshness_limit": "Native check identity/app required binding is necessary but not universal/atomic. Actual participating final-write admission must consume fresh tuple. Any unconstrained direct/bypass/race route is disclosed coverage gap.", + "preactivation": "Diagnostic preservation only. Current mappings, publisher, trusted producer/attempt/private-custody transport and actual enforcement capability are not supplied. No existing scopes/required checks removed.", + "selected": "Distinct formal-regression condition alongside existing verify/public-intake/public-shop; current aggregate not silently repurposed.", + "source_tampering": "PR data may not change T/P/effective workflow/producer/gate authority. Default-source controller source and all executed dependencies must match admitted pins; any mismatch is non-success.", + "status_subject": "Native H; checked sourceS separately in sealed evidence. Native evaluated commit semantics require actual capability tests.", + "stop_conditions": "Any failure, malformed/unknown source or custody, ambiguous attempt, drift, denied capability, unsupported size/schema, preservation/cleanup failure returns FAIL/UNRESOLVED/SUPERSEDED. No retry/alternate auth/identity." + }, + "resource_and_recovery": { + "acquisition_limits": "64MiB total original/decompressed retained evidence;1024members;4MiB each metadata response. Stop oversized transport; label any partial acquisition explicitly incomplete negative.", + "adapter_limits": "Unchanged16MiB packet,4MiB capture,depth64,256nodes,2048edges. No record-group splitting to evade bounds.", + "atomicity": "New source-external directory, no-follow bounded regular members; seal/fsync/index; atomic promotion after complete upload/native readback. Prior valid outputs retained on failure.", + "idempotency": "Same source/evidence duplicate event does not run again; new evidence/acquisition version preserves history and stable source key. Unknown delivery/refusal stops until separately scoped changed-input recovery.", + "privacy": "Public allowlist projection has distinct digest; no private absolute paths/access links/credentials/private original bodies. Actual private carrier capability is missing, never inferred from digest.", + "retention": "At least30days initial native preservation; actual existing-governing-custody readback before expiry for long-term acceptance. Expired originals are unavailable, not reconstructed." + }, + "revision": { + "finding": "R1", + "id": "R01", + "root_scope": "PR325/6244260092", + "state": "REVISED_DRAFT_REQUIRES_FRESH_WHOLE_TECHNICAL_REVIEW", + "whole_review_sha256": "765e368ab137b26d15a6e740878d45ab43d7aaae370ab100f19c9c72eeb9e572" + }, + "schema_version": 1, + "source_cut": { + "Main": "6fce9b8c1a9e723dd4983bfc0d2ebeede09c87f8", + "tree": "5b3447fa17a4f6596ad585da81cd249b3906404d" + }, + "spec": { + "bytes": 23965, + "file": "proposal/docs/superpowers/specs/2026-10-18-formal-regression-collector-design.md", + "mode": "0444", + "nlink": 1, + "sha256": "d01556e9585f5825379e2dd6c44314102e4e23688d5a24c5316d81581f808660" + }, + "technical_acceptance": "NOT_ACCEPTED; R1 amendment pending fresh distinct whole technical review" +} diff --git a/docs/superpowers/plans/2026-10-18-formal-regression-collector-implementation.md b/docs/superpowers/plans/2026-10-18-formal-regression-collector-implementation.md new file mode 100644 index 000000000..294f7396f --- /dev/null +++ b/docs/superpowers/plans/2026-10-18-formal-regression-collector-implementation.md @@ -0,0 +1,191 @@ +# Formal Regression Collector Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Deliver authentic old/candidate formal collection, complete review regression and a protected required consumer for every actually admitted research domain. + +**Architecture:** Admitted T/P controls acquisition and hosted credential-free production. Offline verification preserves ABIs and whole-group review; separate publisher/write admission requires fresh context. Tasks deliver real mapping, declaration authentication, custody and held-out review. + +**Tech Stack:** Python3.11+ stdlib; existing Main Lean `leanprover/lean4:v4.34.1`; separately qualified hosted Linux/runtime and native APIs. No new Python package dependency. + +**Spec:** R01 `docs/superpowers/specs/2026-10-18-formal-regression-collector-design.md` plus `docs/architecture/formal-regression-contract.json`, exact accepted copies carried/pinned in this packet. Root03:16:51 admitted design for planning; fresh PLAN review remains pending. TASK-REQUIREMENT-MATRIX.json carries complete cases/dependencies; immutable historical status fields stay historical. + +## Global Constraints + +- Plan only: all8 ACTIVE_UNMET/org0/source exposed/science NONE/no status authority. No collector semantic approval. Standing AGENTS removes owner reapproval; technical review/current ownership/capability remain. +- Project execution is hosted/ephemeral only; no laptop Git CLI/repair. Use isolated owned source/native objects/guarded refs and protected integration, preserving unrelated Main; no global reservation/unknown writer resumption. +- Preserve B=current base, H=head/status subject, S=service merge, T=admitted control, P=policy digest, K=native checkout, M=landed merge. Verify actual parents/tree/event/control source; these identities are not interchangeable. +- Request key is SHA256(canonical `{domain:formal-regression-request/v1,context:RequestContext}`). Inventory digest is the one exact R01 core/canonical ASCII/SHA256 formula, excluding run/acquisition/attempt provenance but retaining it separately. No supplied status/checksum replaces source/native authentication. +- Keep adapter v1 stdin/four expected-context options/report, `custody: unknown`, native Main/Math schemas and existing required checks. Independently authoritative gate SHA256`a78f3e25f3b0cfe113e618a4c31a7a25d7f22af638c46dec1ecba221fa333ac8` cannot be changed by packet provenance. +- Adapter limits16MiB packet/4MiB capture/depth64/256nodes/2048edges. Acquisition64MiB total retained originals/decompression,1024members,4MiB each metadata response. Never split whole review groups or omit originals to fit; overflow is incomplete/non-success. +- Preserve originals/failures/corrections. Native retention>=30days; governing-custody transfer/readback precedes expiry. Denied/unknown delivery stops, no retry/guessed attempt/alternate identity; changed input gets new acquisition. +- Qualify private custody first. Public allowlist/digest excludes private paths/links/bodies/secrets; Actions artifacts are not presumed private. +- Basis stays Main6fce/tree5b3447; Root3edacfe5/a420 conserves17 dependencies plus21st workflow, source-only. Refresh current source/claims before writes; no run rebinding. + +## Review Focus + +1. H!=S/base drift: native context and write-boundary tests refuse stale evidence (Tasks3,7,9). +2. Forged type stdout/metaprograms/initializers: require actual declaration observation, not transcript shape (Task4). +3. Whole original reviews across downstream/deleted/context edges: retain every use/six-field ref (Task6). +4. Private/partial/cancelled acquisitions: bounded honest terminals, no second original GET or public leak (Tasks3,5). +5. Recollection/proof edits/lost selectors: stable content hash and independent semantic/native predicates (Tasks1,5,6). + +## Files and shared interfaces + +The eleven paths (complete responsibilities/controls in matrix): + +| Path | Responsibility | +|---|---| +| `architecture/formal_regression.py` | Closed contracts, content projection, adapter/formal impact, pure decision. | +| `tools/formal_regression_collect.py` | Authenticated native transport and atomic private preservation. | +| `tools/formal_regression_native.py` | Trusted supervisor, hostile isolation, observations/disposal. | +| `tools/formal_regression_verify.py` | Offline verification and participating-write admission. | +| `tools/formal_regression_publish.py` | Narrow check publication/readback; no source/ref/settings authority. | +| `.github/workflows/formal-regression.yml` | Admitted event/acquisition/verification/publication controller. | +| `.github/workflows/formal-regression-native.yml` | Qualified preparation and credential-free producers. | +| `docs/architecture/formal-regression-policy.json` | Actual domain/control/authority/runtime/custody/publisher/enforcement policy; admission pin outside candidate. | +| `claims/formal-bindings.json` | Actual accepted links and exhaustive typed coverage. | +| `tests/test_formal_regression.py` | Frozen contract/transport/semantic/security controls. | +| `tests/test_formal_regression_enforcement.py` | Actual principal/context/protection/admission controls. | + +. Additional exact paths (Task0 reconciliation): `.github/workflows/formal-regression-controls.yml` (dedicated hosted controls); `tools/formal_regression_declarations.lean` (conditional trusted observer); `tests/fixtures/formal_regression/control-plan.json` (frozen inventory); `tests/fixtures/formal_regression/inventory-conformance.json` (exact82,499B accepted synthetic data); `docs/architecture/formal-regression-contract.json` (exact accepted DATA); `docs/architecture/formal-regression-runbook.md` (activation/recovery/retention); accepted spec and this plan under `docs/superpowers/{specs,plans}`. Existing native/graph/shared-workflow edits require separate exact scope/review/pins. + +`Record=dict[str,object]` denotes a closed DATA type; preserve all accepted type/field names. Internal `InventoryResult={core,formal_inventory_sha256,diagnostic_inventory_sha256,issues}`, `ImpactReport={semantic,evidence_loss,original_groups,affected_original_refs,issues}`; no native/core schema change. + +Cycle C: freeze controls/method inventory; hosted assertion RED; admitted implementation; unchanged normal/`-O` GREEN; distinct originals/source/runtime/cleanup review; guarded increment. Import/setup/skip/corrupt fixtures mean HOLD, not functional RED. An API scaffold is not functional admission. Fixtures/gold stay unchanged. + +Hosted commands: `python3 -B -S -m unittest discover -s tests -p test_formal_regression.py -v` and `python3 -B -O -S ...`; enforcement uses `-p test_formal_regression_enforcement.py`. Matrix lists exact task classes/cases. Preserve every result/stream/exit/original. Only verified Decision.PASS permits required success. + +## Task0: Current source, actual owners and finite scopes + +Files: Current source/claims/Work Events/policy; all proposed paths. No implementation before this gate. +Interfaces: Accepted design/review/disposition -> source/owner reconciliation, admitted authorities and named finite code/control/native/custody/publisher scopes. + +- [ ] Read bounded current PR325/board/Work Events/native identities; identify actual product/control/runtime/authority/publisher owners before pickup. UNKNOWN requires current finite assignment through project coordination, never takeover or renewed owner permission. +- [ ] Compare current complete Main/all17 dependencies and proposed extensions with SITE/Goal1/4 active scopes; preserve every unrelated leaf. Path absence is DATA, not evidence of no active writer. +- [ ] Obtain fresh whole-PLAN review/coordinating admission; establish isolation/owned branch/rollback checkpoint and public-screen exact design/contract/conformance copies. +- [ ] Record actual M1–M7 actors/capabilities/deadlines. Continue independent tasks; missing input blocks dependent activation. + +## Task1: Frozen external controls and closed inert core + +Files: Core, both tests, DATA/conformance copies, control-plan/controls workflow; policy starts diagnostic/unresolved. +Interfaces: `decode_request(raw:bytes)->RequestContext`; `decode_policy(raw:bytes,expected_sha256:str)->Policy`; `request_key(context:RequestContext)->str`; `content_inventory(records:list[TargetStatement],policy:Policy,membership:Record,acceptances:Record)->InventoryResult`; `inventory_sha256(core:Record)->str`. + +- [ ] Freeze matrix `ContractControls` and exact9-preimage fixtures. +- [ ] Independently review/freeze controls and qualify the dedicated hosted caller/preparation/resource/original-custody path without publisher credentials. +- [ ] Run C's normal/optimized assertion RED on the frozen original/scaffold; missing import is not that witness. +- [ ] Implement exact R01 nested forms/order/projection/null/known-absence/digests and strict decoding; never execute candidate Python/config/hooks or a supplied gate. +- [ ] Run unchanged controls GREEN and CLI/API refusals; qualify originals and distinct source review before the guarded increment. Synthetic positives retain unknown real authority/custody. + +## Task2: Actual typed mappings and whole-review authority + +Files: Binding/policy/core, `MappingAuthorityControls`, private authentic originals. +Interfaces: `resolve_coverage(binding:Record,base:Record,candidate:Record,policy:Policy,acceptances:list[AuthorityAcceptance])->Record`, exactly `{node_rows,target_rows,unresolved,accepted_manifest_sha256}`. + +- [ ] Freeze/run all matrix `MappingAuthorityControls` RED. +- [ ] Route exact graph/native package/target/source/slice inventories to actual qualified domain authors and mapping authority. Obtain real typed connections or supported exclusions and immutable native acceptance bound to resolved graph/manifest/scope/domain. Every node/target is linked, accepted outside-domain or unresolved. +- [ ] Acquire current Math inputs under its own authority/native format when admitting that domain. Main31 SIDE24 targets and graph49 nodes never create a Math map. +- [ ] Retrieve each original review/evidence by six-field GitRef, all uses, immutable acceptance/version and actual lineage under existing policy. Unknown or same-lineage evidence stays unresolved; collector supplies no semantic verdict. +- [ ] Implement authority/coverage; run C GREEN; separately qualify real acceptance readbacks and matrix negatives. + +## Task3: Native transport and private preservation + +Files: Collect CLI/policy/core; `TransportControls`, `PreservationControls`. +Interfaces: `collect(request_context:RequestContext,admitted_policy:Policy,native_reader:NativeReader)->Record`, exactly `{bundle_dir,bundle_sha256,terminal,issues}`. NativeReader implements the seven accepted primitives, returning raw bytes plus NativeObservation; acquisition/principal labels alone are not authentication. + +- [ ] Freeze/run matrix `TransportControls`/`PreservationControls` RED. +- [ ] Establish actual CI principal and attempt/job/artifact/supervisor joins; interactive connector access is insufficient. Preserve denied/unsupported calls without alternate identity/retry. +- [ ] Qualify a real private carrier using nonsecret write -> metadata readback -> raw-byte/hash equality, access/privacy refusals and retention transfer. Acquire no private source/review material before this passes. +- [ ] Implement no-follow bounded atomic staging outside source. Record `(repository,run,attempt,artifact_id)` ATTEMPTED before each original GET and exact outcome afterward; unknown/before-byte failure remains terminal. Changed-input recovery gets a new acquisition and preserves the old negative. +- [ ] Run C GREEN and actual transport/private-custody probes; qualify independently originals/disposal. + +## Task4: Trusted declaration observation and hostile native execution + +Files: Native supervisor/workflow/policy, conditional Lean observer; `NativeBoundaryControls` and actual hosted originals. +Interfaces: `produce_native(requested_K:Record,actual_native_event_context:Record,admitted_TP:Record,sandbox_contract:Record)->Record`. Observer CLI consumes `--checked-artifacts --targets --output`; closed observation `{schema_version,checked_source,compiler_context,targets,issues}` binds actual declaration/module/type identity and exact native record slices. API/provenance must be qualified before admission. + +- [ ] Freeze/run actual-hosted matrix `NativeBoundaryControls` RED. +- [ ] Inspect pinned compiler/leanchecker/producer source and runner APIs in bounded hosted preparation. Implement a reviewed observer of kernel-validated declarations without candidate initializer/metaprogram execution in its trusted phase. Stop candidate work first; only this separate observer writes supervisor evidence. Verify target/module/printable-type binding. +- [ ] Demonstrate legitimate/type-changed declarations and rejected forged stdout/initializers. Shape, same-process nonce/FD or isolation alone is insufficient. Unsupported actual API means preserved probe/HOLD `DECLARATION_AUTHENTICITY_UNAVAILABLE`, requiring a reviewed usable observer/compiler release, never an auth flag. +- [ ] Qualify T-pinned Lean/runtime/dependency/preparation originals; existing Python/Main install evidence is insufficient. Workers:`--pull=never`, no network/credentials/socket/sensitive mounts; read-only source/control/toolchain, nonroot, caps dropped/no-new-privileges, bounded output. +- [ ] Probe proposed2CPU/4GiB/256pids/1800s;45min=1800worker+300prep/inspection+120disposal+300custody+180reserve. Unsupported fit/capacity is HOLD, not inflation;64MiB retained total across contexts. +- [ ] Execute fresh B/S normal/optimized supervisor contexts. Preserve all native logs/receipts and protected K/event/T/attempt/command/exit/resource/disposal/source-after observations; distinct qualification precedes M3/native PASS. + +## Task5: Authentic two-sided bundles and content inventories + +Files: Core/collect/native/controller files; `CollectionControls`. +Interfaces: `assemble_bundle(request:RequestContext,policy:Policy,observations:list[NativeObservation],native_records:list[TargetStatement],authority:Record)->Bundle`; collect CLI`--request --policy --expected-policy-sha256 --output`, exact-once options/no secret arguments. + +- [ ] Freeze/run matrix `CollectionControls` RED. +- [ ] Acquire actual B/S sources/native originals/reviews once; preserve Main origin/copy and Math parent resolution. Reuse only qualified same-context captures, never reconstruct execution. +- [ ] Implement lossless framing, actual compiler/dependency/scope/import projection and R01 inventories. Preserve raw records/refs; unavailable types are unresolved, not semantic null deltas. +- [ ] Hash/fsync/seal/preserve/read back the complete Bundle/GraphDescriptor/terminal even for pre-worker failures. A source-content store may deduplicate explicit source identities; distinct native execution/attempt originals must all remain preserved. +- [ ] Run C GREEN plus an authentic unchanged B/S acquisition and actual negative/partial cases. Recollection preserves request/content hashes while separate custody advances; it creates no kernel/alignment currency. + +## Task6: Complete impact and actual detached revalidation + +Files: Core/tests, authentic review records in governed custody. +Interfaces: `compare(base:InventoryResult,candidate:InventoryResult,adapter_reports:list[Record],graphs:Record,authority:Record)->ImpactReport`; `validate_revalidation(record:Revalidation,bundle:Bundle,authority:Record)->Record`, exactly `{accepted,unresolved_original_groups,issues}`. Adapter CLI retains four once-only expected options and labeled context; original packets/reports remain unchanged. + +- [ ] Freeze/run matrix `ImpactControls` RED. +- [ ] Implement separate semantic/evidence channels and pinned gate union traversal of every old/new edge. Original graphs remain original; hold clones are derived. Select refs from authentic OLD links, retaining deletions and all surviving group uses. +- [ ] Validate complete detached context/groups/refs/native authority against R01; preserve reviewed_graph/reviewed_bindings and6112554711. New commit/native success alone cannot revalidate. +- [ ] Obtain real independently authored/accepted revalidation for an affected group, retaining originals/replacement acceptance. Missing review is HOLD. Task10 uses a different unfitted transition. +- [ ] Run C GREEN and distinct whole-group/native-ABI conservation review over authentic original/candidate reports. + +## Task7: Independently admitted T/P controller and all-event coverage + +Files: Controller/native/controls workflows, policy/runbook; `ControllerControls`. +Interfaces: Emits accepted RequestContext/Acquisition/Bundle; effective controller/producer/workflow/dependencies equal externally admitted T/P, candidate edits remain data. + +- [ ] Freeze/run matrix `ControllerControls` RED. +- [ ] Admit immutable T and an actual installed route proving effective workflow source. Protected control refs require native readback; dispatch-by-SHA is not presumed. Metadata-only launchers cannot grant credentials; independent credential/publisher binding verifies actual T/job source, not YAML self-attestation. +- [ ] Implement separated trusted acquisition, tokenless production, offline verification and narrow publication; bind each native job/attempt/artifact. No credentialed candidate execution or ambiguous matrix output. +- [ ] Connect all listed PR events without path filters; base pushes invalidate B/S, evidence/review updates extend only unchanged source, metadata updates recheck context/idempotency. Main M is separate; branch pushes diagnostic; scope remains per domain. +- [ ] Run C GREEN and actual installed-route event/attempt/tamper/early-failure controls; independently admit exact effective T/P. A merge or Actions app15368 does not establish trusted control execution. + +## Task8: Offline decision and actual narrow publisher + +Files: Core/verify/publish/policy; `DecisionControls`, `PublisherControls`. +Interfaces: `verify(bundle:Bundle,admitted_policy:Policy,fresh_native_context:Record)->Decision`; verify CLI`verify --bundle --policy --expected-policy-sha256 --native-context --output`. `publish(sealed_PASS:Decision,final_native_context:RequestContext,admitted_installation:Record)->NativeObservation`; publish CLI`--decision --policy --expected-policy-sha256 --native-context --output`. Inject admitted native transport, never candidate URLs. + +- [ ] Freeze/run matrix `DecisionControls`/`PublisherControls` RED. +- [ ] Implement independent raw-member/provenance/core recomputation and all Decision predicates. No-change requires full authoritative coverage/custody and current native positives; adapter exit0 or a diagnostic report is insufficient. +- [ ] Qualify actual app/installation/principal/effective check-only permissions, separate from acquisition/workers. No contents/ref/PR/settings authority; name/app-ID is insufficient. +- [ ] Publish recomputed sealed PASS only after final tuple equality; mark one attempt, then read back exact app/installation/check/body/conclusion at H with S/key explicit. Unknown delivery stays HOLD; public projection has separate allowlist/hash. +- [ ] Run C GREEN plus actual canary legitimate/wrong-principal/stale probes; independently qualify originals and production-scope equivalence. + +## Task9: Protected final-write enforcement and conditional activation + +Files: Verify`admit` mode, enforcement tests, policy/runbook; protection/final-write integration needs separately named actual scope. +Interfaces: `admit(request:RequestContext,decision:Decision,fresh_native_context:Record,check_readback:NativeObservation,admission_capability:Record)->Record`, exactly `{admitted,reasons,observed_context}`; consumed at the participating write boundary, never a permanent permission token. + +- [ ] Freeze/run matrix canary `EnforcementControls` RED; no unsafe production merge. +- [ ] Read current rules/app/check/conversation/write routes. Add formal-regression via qualified operator/native full-rule readback, preserving verify/public-intake/public-shop and no bypass. +- [ ] Implement fresh report/check/B/H/S/T/P/source consumption and real drift refusal. Expected-H alone does not enforce expected-B. Probe actual race behavior; separately qualify any queue/other merge mode's real parents/events. +- [ ] Prove rejection on claimed routes; disclose unconstrained routes. Missing race-control capability keeps diagnostic/non-success/HOLD; a fresh GET is not atomic enforcement. +- [ ] Run C GREEN and non-destructive production negatives/readbacks; independent policy/install/protection/route review precedes blocking activation. Main does not certify Math/all writers. + +## Task10: Unfitted real transition and actual nonauthor review + +Files: Private held-out source/review/capture/report originals, enforcement tests/runbook; no scientific registers. +Interfaces: Real B/S/mapping/old whole review -> ImpactReport -> authentic Revalidation/AuthorityAcceptance -> protected Decision/publication/admission. + +- [ ] Have a qualified owner seal an unfitted real statement/premise transition, downstream original review and selection lineage; synthetic fixtures/Main31 cannot substitute. +- [ ] Collect genuine sources/declarations/types, complete union impact/exact refs and real proof/unscoped/selector/deleted-edge calibration; execution failure is not semantic change. +- [ ] Obtain actual nonauthor mathematical/alignment revalidation and native acceptance for every surviving group use at exact context. Retain originals/exposure/lineage; acquire a missing reviewer/capture/authority through project coordination, never self-approve. +- [ ] Run the real transition through private readback/verifier/required publisher/protected admission; retain exact positive/negative evidence. +- [ ] Obtain distinct whole-source/security/evidence qualification and scoped M7 acceptance. Domain reviewers handle science; implementation promotes none. + +## Task11: Same validated artifact, domain rollout and recovery + +Files: GraphDescriptor/collector/controller/policy/runbook; SSG paths remain with actual separately reconciled Goal1/4 owner. +Interfaces: Exact descriptor fields`carrier_graph_ref,upstream_provenance_ref,gate_sha256,exporter_source_refs,graph_artifact_ref,graph_sha256,regression_report_sha256`; S/native run/attempt remain bound in custody. Deliver original exporter-compatible graph bytes, not a hold clone/re-export from another source. + +- [ ] With actual bundle/SSG owner, qualify same-graph acceptance and wrong artifact/run/attempt/graph/report/S refusals using exact pins/native build readback. Keep SSG open until paired consumer evidence. +- [ ] Roll out each domain after its own full gates; exercise ordinary/fork/metadata/base-update/failed/cancelled/missing/unchanged events, not one Main GREEN. +- [ ] At M verify parents/tree against S and observe natural Main push separately. Recheck source/claims/checks before protected integration; conserve SITE/RAG/unrelated leaves and negatives. +- [ ] Exercise denied/unknown delivery, changed-input acquisition, retention transfer and last-admitted-T/P rollback without stale success/old-output loss. Unsafe enforcement stays non-success; temporary policy rollback requires named technical disposition/native readback, no silent bypass. Retain rules/reports. +- [ ] Obtain independent whole-branch/source/evidence review and per-domain acceptance/recovery records. Release only completed scopes; full8 additionally requires the other seven requirements and actual same-artifact SSG. + +**Execution handoff:** Fresh whole-PLAN review/admission precedes finite implementer/reviewer assignments. No user reapproval; current source, unchanged controls and qualified originals govern. diff --git a/docs/superpowers/specs/2026-10-18-formal-regression-collector-design.md b/docs/superpowers/specs/2026-10-18-formal-regression-collector-design.md new file mode 100644 index 000000000..03de01964 --- /dev/null +++ b/docs/superpowers/specs/2026-10-18-formal-regression-collector-design.md @@ -0,0 +1,126 @@ +# Source-bound formal regression collector and required consumer + +Draft R01 for fresh whole-spec review, 18 October 2026. Original author: OpenAI/Codex `/root/native_object_conservation_1017`, source exposed, org0. Root assigned this design-only continuation at PR325/6243925080 (00:52:16 UTC), the separate extension promised by6069575569, not an older accepted collector handoff. No implementation plan, code or activation. Science NONE/authority false; all8 ACTIVE_UNMET. + +## Intent and established boundary + +Complete original Task2: preserve actual base/candidate reports for every PR, consume them at an exact-candidate required gate, and qualify actual formal-change controls/nonauthor review. Preserve existing graph, reviews, negatives and independent evidence axes; create no global graph/status/ownership register. Requirements1/4 still need the same validated graph artifact consumed by the SSG. This design supplies that interface, not its unfinished integration. + +The frozen source basis is Main `6fce9b8c1a9e723dd4983bfc0d2ebeede09c87f8`, tree `5b3447fa17a4f6596ad585da81cd249b3906404d`. Later Main changes require a new source qualification. Existing adapter76502B/4b73b4a7 and CLI1509B/ad759f3f validate supplied captures, not authentic collection. Their exact v1 ABI stays unchanged. The graph gate remains independently pinned to SHA256 `a78f3e25f3b0cfe113e618a4c31a7a25d7f22af638c46dec1ecba221fa333ac8`; packet provenance cannot change executable authority. Main/Math native formats stay distinct. Main's31 SIDE24 targets supply no graph-node mapping. Missing real mappings and review custody therefore remain unresolved and prevent blocking-mode success. Current carrier is `docs/site/dependency-source/GRAPH.json`:49nodes/55edges, dated Math origin `7858329974e28be79f29b22644370084ff43da4f`, not current Math. + +## Alternatives and selected approach + +| Approach | Operation and tradeoff | Decision | +|---|---|---| +| Trusted controller, isolated producers, separate publisher | Default-trusted metadata code acquires native sources; reviewed isolated producers execute candidate data without credentials; independent verifier/publisher supplies a new required condition. Needs actual transport, publisher and freshness-enforcement capabilities. | Selected; these capabilities are not presumed installed. | +| Candidate-owned workflow inside existing `verify` | Add packet/report dependencies to current PR workflow. Simple, but PRs can edit workflow, verifier and dependency code. Reusable names/Actions app15368 do not establish trusted execution. | Rejected as trust boundary; fixture discovery remains useful. | +| Detached owner packets/manual admission | Authenticate each packet manually, then use current adapter. Useful changed-input recovery, but no automatic every-PR collection/enforcement. | Recovery only; never automatic successful fallback. | + +Selected required condition: existing checks AND distinct `formal-regression`. Preserve `verify`, `public-intake`, `public-shop` and their meanings. Later workflow/publisher/protection edits require exact-scope coordination; proposed names transfer no peer ownership. + +## Roles and immutable context + +The trusted controller reads metadata and source only. It never executes a PR checkout. Its effective executable/control revision `T` and policy digest `P` are independently admitted outside the PR. A candidate change to those files is data until a separately reviewed control release is admitted. Even a newer default branch does not silently replace `T` or `P`. + +Request context binds repository/PR, base repository/ref/commit/tree `B`, head repository/ref/commit/tree `H`, service checked-merge commit/tree `S` and parents, admitted control revision `T` and policy digest `P`. `B` is current target tip, not fork point. Required comparison is `B -> S`; retain `H` separately as attribution/native check status subject. A run `head_sha`, target-event `GITHUB_SHA`, or `H` is never silently equated to tested `S`. Event/collection identity and native observations are acquisition metadata, separate from stable source context. + +Require native readback of the configured `B/H/S` parent relationship and exact tested tree. Missing/conflicting service merge is `UNRESOLVED_CANDIDATE`, never head-only fallback. Optional head/fork-point comparisons are diagnostic. Different service merge semantics need separate review and an actual capability witness. + +Producer context `N` separately records repository, checked commit `K`, run head, workflow/control source, job, run ID/attempt, purpose and conclusion. Each capture retains its context. Supervisor records requested `K` separately from native event/control SHA; changing environment values cannot turn an event at `T/B` into native proof of checkout `S`. A Main run cannot refresh Math evidence; equal bytes or a new sidecar cannot rebind an old receipt from `K` to `S`. Landed merge `M` is a new observation: verify parents/tree against `S`, retain the original checked identity and qualify any Main-push run separately; tree equality does not relabel an `S` run as `M`. + +All PR open/reopen/synchronize/base-edit/ready events request a report, without path filters. Metadata-only updates reuse immutable captures only after fresh context checks, not execution replay. Base pushes invalidate affected outstanding contexts; producer completion/review updates may extend evidence for unchanged context. Main push is separate postmerge observation, never retroactive admission. Branch pushes supply diagnostic evidence only. Coverage is per admitted repository/domain: initial Main rollout does not establish Math/all-repository enforcement. Current collector/product ownership remains UNKNOWN; this assignment owns only the draft. + +## Collection contract and source membership + +`collect(request, policy, native_reader) -> bundle` requires authenticated commit/tree/blob and PR/merge reads, attempt-specific job/artifact identity, one bounded original-artifact read, review retrieval and preservation readback. Agent-connector availability proves no CI transport capability. Missing/denied capabilities preserve non-success; no alternate identity, retry, guessed attempt or PR-selected URL. + +Save complete native responses before parsing, with request/time/principal-scope labels and byte digest; exclude tokens/access URLs. Resolve trusted-policy/typed paths. Verify bytes/SHA/Git-blob framing, repository/commit/path membership, native mode/tree, and repeated identities. Reject duplicate paths/keys, symlinks/special files/submodules, escapes and unsupported LFS. Reconstruct complete trees where possible; distinguish verified tree/blob hash from authenticated service commit-to-tree assertion. Normalized metadata alone does not reconstruct a signed commit hash. + +Inventory relevant package members, including manifest-bound/unbound files, scope/imports, toolchain/locks, producer/control source and informal origin/local copy. Preserve Main origin versus checked-copy roles. Resolve Math file keys against its manifest parent without rewriting them or adding Main rows. Missing/unsupported source is availability loss; no same-title/target/hash substitute. + +Use the existing admitted validated graph, its carrier GitRef, dated upstream provenance and independently pinned gate. Qualify carrier/upstream membership separately; preserve original nodes/edges and dated origin. Emit existing exporter-compatible `graph.json` and bind its bytes. A changed graph/provenance pin requires source review; private evidence custody and public export remain separate. + +## Authoritative mappings and actual statement inventory + +Proposed `claims/formal-bindings.json` links each graph node explicitly to native format/package/target/module, known informal source/slices and exact original alignment GitRefs. Snapshot-relative references carry path/blob/SHA/bytes plus `base`/`candidate` role; collector resolves actual `B/S` commit. External origins use full immutable refs. External acceptance binds resolved manifest/graph/source identities, avoiding self-referential commit hashes. Candidate links require admitted mapping-authority acceptance; merged files, titles/shared hashes do not authorize links. + +Coverage enumerates every admitted node/target as linked, explicitly outside domain with accepted scope evidence, or unresolved. Empty/missing/ambiguous/lost mappings fail coverage. Candidate-only exclusion is unresolved; Main's31 targets cannot certify global scope. Current authoritative mapping/acceptance is absent: diagnostic output must expose this and blocking success is unavailable. + +Collect both sides' exact manifest rows, modules, scope, dependency/toolchain/compiler/options, and target records from original qualified `elaborated-types.log`. Use lossless target-header/indented-continuation framing; retain whole log plus every record's byte offsets/hash. Require one complete record per native target, no foreign/duplicate/ambiguous output and admitted print options. Main uses `pp.explicit true`. Printed type data is not semantic normal form/equivalence, and a parser cannot authenticate `#check`-shaped text. + +Authenticate producer source/runtime before crediting observed statement data. Old native evidence binds `B`, candidate binds `S`; an older checked identity remains explicit and unresolved for that side. Byte conservation is not fresh execution. Changed toolchain/options/dependency context makes comparison unknown and requires revalidation even when printed text matches. + +Comparable changed type bytes yield conservative `formal_statement_changed`; target addition/deletion, consumed-premise, scope/manifest-contract changes also seed revalidation. A changed module with equal type records is `formal_source_changed_unscoped` unless accepted body/declaration selectors and unchanged statements/context establish proof-only change. Whole-file hashes never become statement slices; equal types never certify informal alignment. Preserve6112554711: informal selector-only edit/loss can hold alignment without asserting failed/stale kernel evidence by itself. + +## Native production and custody qualification + +Native workflow verifies `B/H/S`, uses admitted control/producer `T` and separately prepared pinned runtime. Candidate config/source is untrusted. Compile/build runs only in a disposable hosted sandbox with reviewed nonroot/no-network/resource/cleanup controls, read-only source/control/toolchain, separate bounded output and no repository/cloud/publisher credentials. PR workflow/tests/hooks/setup never execute in privileged controller jobs. A candidate producer script cannot attest itself. + +Trusted supervisor records actual source, commands/executable pins, exits and runtime bounds outside candidate-writable storage; stops/removes execution before collection. Reuse Main producer semantics/format through a reviewed supervisor adaptation, not an assumption the existing script safely handles arbitrary packages unchanged. Real adversarial controls must address metaprogramming, output injection and build config. Sandbox/stdout/artifact presence proves neither perfect protection nor semantic review. + +Join native run/attempt/job/artifact/member identity, original ZIP/member bytes, receipts/logs and supervisor observations. Current Main receipt does not independently check an attempt field; required binder adds environment/output context. Qualify attempt through actual attempt-specific artifact/job/supervisor custody or mark `ATTEMPT_UNKNOWN` and refuse positive execution. Never infer it from name/current metadata/adapter expectation. Preserve failed/skipped/cancelled/timed-out/missing/negative-control records; only genuine successful positive checks support their native target kernel axis. + +## Regression, originals and review revalidation + +Keep unchanged adapter ABI/reports and `custody: unknown`. Produce historical-original and candidate projections using old/candidate formal records respectively and explicit expected native context. A single context is not cross-run/repository currency. Whole original groups must not be partitioned to hide uses. Math's absent Main-style bridge remains unknown; the wrapper does not promote adapter kernel axes. + +Add a separate formal-impact projection because adapter fingerprints do not compare target types. Feed the same pinned `reverse_impact_between` complete per-node semantic fingerprints: accepted links, type/context content and scope/manifest contract. Track execution/availability loss through a separate evidence-impact channel. Preserve raw identities; run-ID change alone is not statement change. Normalize paired snapshot commit advancement only as current adapter permits. Validate actual graphs; traverse all old/new edges, including deleted/context edges. Original graphs remain unchanged; any hold-marked clone is derived only. + +Union adapter/formal-impact nodes/reasons; retain deleted/added nodes, removed edges, unscoped changes and unknown mappings. Select affected original reviews only from authenticated old explicit links. Group by full original GitRef. Hold every surviving use of that whole record, including downstream uses; unmapped uses stay unresolved. Fresh run success never refreshes alignment. Execution-only loss fails the native/gate predicate but does not by itself invent a statement delta, stale semantic alignment or affected-review ref; preserve the existing independent-axis contract. + +Retrieve original reviews/evidence by exact identity and authenticate membership/native acceptance/version. Mutable comments need acquired body/update hashes, stable final readback and an accepted immutable review record; ID alone is not immutable content. Native GitHub accounts do not prove model/provider/agent lineage: existing review authority must actually accept that lineage/evidence. Preserve exposure/org0. + +Detached `formal-regression-revalidation/v1` binds stable request key, new graph ref, accepted mapping and formal-statement inventory digests (the one closed DATA.formal_inventory_hash_contract core/SHA256, with declarative preimages in INVENTORY-CONFORMANCE.json), manifests/scopes, every original GitRef and successor review/evidence refs. Require all surviving whole-group uses and actual accepted revalidation or explicit unresolved scope. Preserve native alignment schemas and reviewed_graph/reviewed_bindings rules. Authority's native acceptance binds exact detached bytes/context; newer commits or candidate `ACCEPTED` strings are insufficient. + +Detached review commits refer to existing `S` without changing `H/S`. Preserve stale originals/affected refs after successor coverage; outer decisions link qualified replacements without erasing history. Collector never performs semantic review, invents reviewer PASS, rewrites originals or dispatches a mathematical verdict. + +## Report, verifier and required decision + +Bundle binds request/control/policy; raw inventory/membership/custody; accepted mapping/coverage; old/new types; unchanged adapter packets/reports; formal impact; original/successor reviews; exact graph artifact; retention/readback and issues. Index hashes every member and role; originals stay byte-exact. Stable request key hashes canonical domain `formal-regression-request/v1` and repository/PR/B/H/S/T/P plus merge mode. Exclude event/acquisition IDs, timestamps and evidence revisions: evidence may extend without moving source context. Different B/H/S/T/P means a new key. + +`verify(bundle, admitted_policy, fresh_native_context) -> decision` uses only admitted verifier/adapter/gate bytes, rehashes members and recomputes projections. No supplied success/checksum/needs-output substitutes for custody. Authenticate bundle provenance against the admitted acquisition workflow/job/attempt and native artifact; a self-declared principal label cannot establish custody. PASS requires complete authoritative coverage, authentic source/types/native context, supported producer/attempt, current candidate binding, authenticated whole-group revalidation, successful preservation/readback and exact final context. Missing/failed/skipped/stale, malformed/partial/unknown/oversized input is non-success. Adapter exit0 with stale/unknown data is not gate success. + +No-change PASS still requires complete authoritative coverage/custody and independently required current native checks. Before those exist, no-delta diagnostics remain unresolved. Decisions: PASS/FAIL/UNRESOLVED/SUPERSEDED; only PASS permits successful required result. Preserve historical adapter axes and scientific NONE. + +Separate read-only acquisition from narrow check-publisher principal. Publisher executes no candidate code, accepts sealed recomputed PASS only after final native B/H/S/T/P equality, and reads back exact check identity/body/conclusion. Proposed name `formal-regression`; actual app/installation is an absent activation input, never presumed15368. Publish at native status subjectH, with explicit checkedS/request key. Capability tests must establish platform head/merge evaluation; H publication never asserts H==S. + +Check success is as-of publication, not atomic later-merge authority. Participating merge admission re-consumes the sealed report and freshly verifies B/H/S, check/P/T/source guards at its write boundary; drift refuses, never rebinds. Cached strict rules are not current enforcement proof. Name/app binding cannot constrain alternate/bypass writers or every base race. Blocking activation needs actual stale/spoof enforcement probes and an admitted final-write path. Unconstrained routes keep enforcement incomplete; diagnostic collection may operate. No completed lease broker/global Main lock is invented. + +## Preservation, privacy and recovery + +Use fresh bounded acquisition directory, complete sealed members/index/report, fsync and atomic promotion outside source. Failure never replaces prior qualified output. Retain adapter limits16MiB packet/4MiB capture/256nodes/2048edges. Acquisition caps64MiB retained originals/decompression,1024members and4MiB per metadata response, checked before allocation. Oversize/truncated acquisition is preserved as an explicit negative, never evidence completeness; greater capacity needs reviewed policy, not splitting away whole-review coverage. + +Preserve native artifact IDs, ZIP/member hashes and actual upload/readback. Minimum retention30days is a deadline, not permanence; long-term acceptance needs existing governing-custody transfer/readback before expiry. Unavailable storage/disclosure capability blocks that claim. Every PR acquisition, including refusal/incomplete cases, preserves a bounded terminal report; failed preservation prevents success. Recollection is a new acquisition, not reconstruction of lost execution. + +Public output is allowlisted public-relative paths/opaque IDs, permitted hashes/context, reasons/scope/freshness. Exclude credentials, private paths/access links, raw private source/review bodies and secret logs. Originals stay in admitted private custody; allowlist rather than cleanup regex. Public projection has its own digest; private digests do not authenticate unavailable contents. + +Refusal/denial/unknown delivery stops without blind retry. Changed-input recovery gets a new acquisition ID and preserves negatives. Duplicate delivery is idempotent for same source/evidence; evidence changes create sealed revisions. Cancelled/missing output never succeeds. Retain actual stop/remove/source-after custody before cleanup; missing cleanup observation is separately unresolved. + +## Proposed file and interface boundaries + +These are prospective paths only, requiring later exact-file ownership reconciliation. No files below are created by this draft except this private proposed spec. + +| Proposed repository path | Responsibility | +|---|---| +| `architecture/formal_regression.py` | Closed bundle/mapping/revalidation contracts, statement framing, pinned adapter/gate projections and conservative policy decision; no network or credentials. | +| `tools/formal_regression_collect.py` | Trusted native-reader transport, membership acquisition and atomic bundle preservation. | +| `tools/formal_regression_native.py` | Trusted supervisor adapter for isolated native production and external command/source/runtime observations; no publisher credentials. | +| `tools/formal_regression_verify.py` | Offline recomputation and final-context admission interface; no publication authority. | +| `tools/formal_regression_publish.py` | Separate narrow check publisher/readback; rejects unsealed, stale or non-PASS input. | +| `.github/workflows/formal-regression.yml` | Trusted metadata/event controller and separated acquisition/verification/publication jobs. | +| `.github/workflows/formal-regression-native.yml` | Trusted supervisor/preparation and credential-free ephemeral native production; source-owner review before use. | +| `docs/architecture/formal-regression-policy.json` | Public-safe reviewed policy: admitted repositories/domains, source/control/gate/producer pins, reviewers/mapping authority, limits, custody/disclosure and enforcement mode. Its admission pin lives outside candidate data. | +| `claims/formal-bindings.json` | Explicit versioned links/coverage; actual authoritative records are not supplied by this draft. | +| `tests/test_formal_regression.py` | External contract/security/negative controls against the proposed CLIs and preserved originals. | +| `tests/test_formal_regression_enforcement.py` | Hosted actual-context/publisher/protection/admission controls, separately qualified from fixture tests. | + +Existing adapter/gate/exporter, native schemas, formal sources/reviews, shared workflows and scientific registers remain dependencies. Required changes need exact-scope extension/review. Graph descriptor exposes original provenance/exporter pins and exact graph/report digests for the future same-artifact SSG consumer; no replacement graph. + +## Evidence required before closure + +Hosted controls: forged self-consistent membership/receipts; missing modes/tree members/identity collisions; privacy/path/archive/resource attacks; PR workflow/verifier tampering; failed/skipped/missing/stale/ambiguous-attempt producers; shell/output failure; stale B/H/S/T/P/wrong app/status subject; deleted/context-edge impact; partial whole-review revalidation; unknown/lost mappings; actual type versus proof/unscoped deltas; toolchain mismatch; atomic preservation/cleanup failure; and legitimate unchanged positives. Synthetic controls are not authentic capture or semantic review. + +After source review and genuine hosted RED/GREEN, use a held-out actual transition not fitted to implementation: native old/new sources/types, authoritative link, changed formal statement/consumed premise, downstream whole original review, complete union impact/exact refs, real independently authored authenticated revalidation, preserved report and protected consumer/admission result. Include proof-only/unscoped calibration and deleted edge. Existing qualified reviewers assess mathematical validity/alignment; this author supplies no real witness, mapping or review PASS. + +Absent activation inputs: accepted resolved mappings/coverage and authority; original review/evidence identities and revalidation authority; admitted control/producer/runtime revisions; working attempt-specific transport/artifact/private custody; narrow publisher installation; current protection/final-admission configuration with actual spoof/stale/missing-producer rejection; and held-out real transition. Defined preactivation behavior is diagnostic preservation/non-success, not another handoff search or accepted implementation. Root retains whole-spec review, later plan/source/runtime/integration/all8 decisions. Author reserves no later role. +R01 author `/root/req8_inventory_contract_revision_0133` addresses only review R1 under PR325/6244260092. Predecessor remains immutable; fresh technical review is pending. diff --git a/tests/fixtures/formal_regression/control-plan.json b/tests/fixtures/formal_regression/control-plan.json new file mode 100644 index 000000000..82e938d5c --- /dev/null +++ b/tests/fixtures/formal_regression/control-plan.json @@ -0,0 +1,7226 @@ +{ + "all8": "ACTIVE_UNMET", + "commands": { + "normal": [ + "python3", + "-B", + "-S", + "-m", + "unittest", + "discover", + "-s", + "tests", + "-p", + "test_formal_regression.py", + "-v" + ], + "optimized": [ + "python3", + "-B", + "-O", + "-S", + "-m", + "unittest", + "discover", + "-s", + "tests", + "-p", + "test_formal_regression.py", + "-v" + ] + }, + "control_plan_state": "R01_FROZEN_FOR_FRESH_WHOLE_REVIEW_NOT_ADMITTED", + "expected_scaffold_summary": { + "errors_allowed": 0, + "expected_assertion_failures": 115, + "held_fixture_positive_count": 1, + "per_mode_method_count": 116, + "skips_allowed": 0, + "status": "STATIC_EXPECTATION_NOT_AN_EXECUTED_RESULT" + }, + "frozen_at_utc": "2026-10-20T12:55:16Z", + "frozen_sources": [ + { + "bytes": 61667, + "path": "tests/test_formal_regression.py", + "sha256": "d3d619f972d7f84b7fe13f417f0381d434cc81fd793298c168cb5c74ed1ab3ba" + }, + { + "bytes": 36526, + "path": "docs/architecture/formal-regression-contract.json", + "sha256": "665fb5e773258c629ce72a73afc59c250ad52d8d6c80f36f48f664949ecb3b4b" + }, + { + "bytes": 82499, + "path": "tests/fixtures/formal_regression/inventory-conformance.json", + "sha256": "b208633fb69f3bb5269bf939ac2d5393bcb66fbf0850995f677276ef2f38d6c2" + } + ], + "held_predicates": { + "collection_prerequisites": "Concrete R01 closed wire + complete raw/native/role/source/producer/import/selector prerequisites are checked before each isolated mutation; product held baseline must equal exact two-target diagnostic core/hash/issues before refusal credit. Actual authority NONE; fresh whole review mandatory.", + "fixture_integrity": "Exact nine independent canonical preimages/hashes and exact accepted raw file pins hold before any behavioral claim; new R01 complete synthetic source joins and distinct-origin preimages also held", + "import_setup": "All five exact functions must import; setup/fixture/dependency/import errors and skips are HOLD, never qualifying RED", + "per_method_RED": "Expected scaffold observations are hypotheses from literal return statements; all remain NOT_EXECUTED until actual hosted per-method originals show assertion failures, not errors", + "positive_predicates": "Canonical valid baseline, all nine vectors, valid request and diagnostic policy must pass unchanged before any negative refusal is credited at GREEN", + "unchanged_GREEN": "Same exact test source/DATA/conformance/control-plan bytes and both-mode inventory; current core may change only after qualified RED and distinct review" + }, + "kind": "FROZEN_FIRST_CORE_CONTROL_PLAN_PROPOSAL", + "mandatory_contract_coverage": [ + { + "actual_execution": "NOT_EXECUTED", + "basis": "Accepted PLAN Task1 / full original Task1 matrix / DATA closed types and inventory hash contract", + "boundary_qualification": "Normative digest/closed schema where explicit; proposed synthetic collection/internal decisions remain HOLD pending distinct review", + "obligation": "five_named_assertions", + "test_ids": [ + "test_formal_regression.ContractControls.test_inventory_baseline_hash", + "test_formal_regression.ContractControls.test_recollection_keeps_content_digest", + "test_formal_regression.ContractControls.test_seven_content_deltas", + "test_formal_regression.ContractControls.test_unknown_required_type_is_diagnostic", + "test_formal_regression.ContractControls.test_duplicate_identity_refuses" + ] + }, + { + "actual_execution": "NOT_EXECUTED", + "basis": "Accepted PLAN Task1 / full original Task1 matrix / DATA closed types and inventory hash contract", + "boundary_qualification": "Normative digest/closed schema where explicit; proposed synthetic collection/internal decisions remain HOLD pending distinct review", + "obligation": "nine_exact_canonical_cores", + "test_ids": [ + "test_formal_regression.ContractControls.test_canonical_vector_0", + "test_formal_regression.ContractControls.test_canonical_vector_1", + "test_formal_regression.ContractControls.test_canonical_vector_2", + "test_formal_regression.ContractControls.test_canonical_vector_3", + "test_formal_regression.ContractControls.test_canonical_vector_4", + "test_formal_regression.ContractControls.test_canonical_vector_5", + "test_formal_regression.ContractControls.test_canonical_vector_6", + "test_formal_regression.ContractControls.test_canonical_vector_7", + "test_formal_regression.ContractControls.test_canonical_vector_8" + ] + }, + { + "actual_execution": "NOT_EXECUTED", + "basis": "Accepted PLAN Task1 / full original Task1 matrix / DATA closed types and inventory hash contract", + "boundary_qualification": "Normative digest/closed schema where explicit; proposed synthetic collection/internal decisions remain HOLD pending distinct review", + "obligation": "strict_duplicate_trailing_nonfinite_depth_oversize_type_bool", + "test_ids": [ + "test_formal_regression.ContractControls.test_request_refuses_duplicate_top_key", + "test_formal_regression.ContractControls.test_request_refuses_duplicate_nested_key", + "test_formal_regression.ContractControls.test_request_refuses_trailing_value", + "test_formal_regression.ContractControls.test_request_refuses_nonfinite_nan", + "test_formal_regression.ContractControls.test_request_refuses_nonfinite_infinity", + "test_formal_regression.ContractControls.test_request_refuses_nonfinite_negative_infinity", + "test_formal_regression.ContractControls.test_request_refuses_depth_over_64", + "test_formal_regression.ContractControls.test_request_refuses_oversize", + "test_formal_regression.ContractControls.test_request_refuses_wrong_root_type", + "test_formal_regression.ContractControls.test_exact_integer_excludes_boolean", + "test_formal_regression.ContractControls.test_policy_boolean_version_refuses" + ] + }, + { + "actual_execution": "NOT_EXECUTED", + "basis": "Accepted PLAN Task1 / full original Task1 matrix / DATA closed types and inventory hash contract", + "boundary_qualification": "Normative digest/closed schema where explicit; proposed synthetic collection/internal decisions remain HOLD pending distinct review", + "obligation": "complete_native_enumeration_identity_foreign", + "test_ids": [ + "test_formal_regression.ContractControls.test_collection_refuses_unknown_enumeration", + "test_formal_regression.ContractControls.test_collection_refuses_ambiguous_enumeration", + "test_formal_regression.ContractControls.test_collection_refuses_missing_enumeration", + "test_formal_regression.ContractControls.test_collection_refuses_unsupported_native_format", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_native_target", + "test_formal_regression.ContractControls.test_collection_refuses_foreign_native_target", + "test_formal_regression.ContractControls.test_duplicate_identity_refuses", + "test_formal_regression.ContractControls.test_conflicting_duplicate_target_identity_refuses" + ] + }, + { + "actual_execution": "NOT_EXECUTED", + "basis": "Accepted PLAN Task1 / full original Task1 matrix / DATA closed types and inventory hash contract", + "boundary_qualification": "Normative digest/closed schema where explicit; proposed synthetic collection/internal decisions remain HOLD pending distinct review", + "obligation": "origin_vs_snapshot", + "test_ids": [ + "test_formal_regression.ContractControls.test_snapshot_source_has_exact_six_content_fields", + "test_formal_regression.ContractControls.test_origin_requires_all_six_full_ref_fields", + "test_formal_regression.ContractControls.test_origin_commit_remains_in_content_digest", + "test_formal_regression.ContractControls.test_collection_refuses_origin_relabelled_snapshot", + "test_formal_regression.ContractControls.test_collection_refuses_snapshot_source_wrong_commit" + ] + }, + { + "actual_execution": "NOT_EXECUTED", + "basis": "Accepted PLAN Task1 / full original Task1 matrix / DATA closed types and inventory hash contract", + "boundary_qualification": "Normative digest/closed schema where explicit; proposed synthetic collection/internal decisions remain HOLD pending distinct review", + "obligation": "full_thirteen_fields_closed_nested_compiler_dependency_build_runtime_scope_import", + "test_ids": [ + "test_formal_regression.ContractControls.test_all_thirteen_target_fields_are_required", + "test_formal_regression.ContractControls.test_nested_compiler_runtime_and_selector_extra_fields_refuse", + "test_formal_regression.ContractControls.test_compiler_dependency_content_closed", + "test_formal_regression.ContractControls.test_compiler_binary_and_version_content_closed", + "test_formal_regression.ContractControls.test_dependency_names_unique_and_revisions_full", + "test_formal_regression.ContractControls.test_runtime_identity_closed", + "test_formal_regression.ContractControls.test_scope_and_import_sets_closed", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_dependency", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_build_role", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_producer_role", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_import_role", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_scope_role" + ] + }, + { + "actual_execution": "NOT_EXECUTED", + "basis": "Accepted PLAN Task1 / full original Task1 matrix / DATA closed types and inventory hash contract", + "boundary_qualification": "Normative digest/closed schema where explicit; proposed synthetic collection/internal decisions remain HOLD pending distinct review", + "obligation": "selector_link_raw_slice", + "test_ids": [ + "test_formal_regression.ContractControls.test_selector_entry_and_slice_closed", + "test_formal_regression.ContractControls.test_selector_bounds_are_exact", + "test_formal_regression.ContractControls.test_selector_link_sets_complete_and_unique", + "test_formal_regression.ContractControls.test_collection_refuses_unknown_selector_acceptance", + "test_formal_regression.ContractControls.test_collection_refuses_foreign_selector_link", + "test_formal_regression.ContractControls.test_collection_refuses_selector_raw_slice_mismatch" + ] + }, + { + "actual_execution": "NOT_EXECUTED", + "basis": "Accepted PLAN Task1 / full original Task1 matrix / DATA closed types and inventory hash contract", + "boundary_qualification": "Normative digest/closed schema where explicit; proposed synthetic collection/internal decisions remain HOLD pending distinct review", + "obligation": "null_diagnostic_refusal", + "test_ids": [ + "test_formal_regression.ContractControls.test_unknown_required_type_is_diagnostic", + "test_formal_regression.ContractControls.test_required_type_null_pair_cannot_be_half_known", + "test_formal_regression.ContractControls.test_required_null_needs_exact_unresolved_name", + "test_formal_regression.ContractControls.test_unresolved_names_are_exact_sorted_unique", + "test_formal_regression.ContractControls.test_collection_unknown_enumeration_has_no_core", + "test_formal_regression.ContractControls.test_collection_zero_links_is_known_absence_diagnostic" + ] + } + ], + "methods": [ + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(len(fields), 13)", + "line": 695, + "operation": "assertEqual" + } + ], + "break_caught": "Any of thirteen required target fields silently omitted", + "category": "closed_target_13", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_all_thirteen_target_fields_are_required", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(inventory_sha256(case[\"core\"]), '4a469c57ba103d8937795c709b59765a689ae24f92b6ee1d55ddc74037b849e6')", + "line": 393, + "operation": "assertEqual" + } + ], + "break_caught": "Incorrect exact canonical digest for unchanged_content_first_acquisition", + "category": "nine_preimages", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_canonical_vector_0", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(inventory_sha256(case[\"core\"]), '4a469c57ba103d8937795c709b59765a689ae24f92b6ee1d55ddc74037b849e6')", + "line": 397, + "operation": "assertEqual" + } + ], + "break_caught": "Incorrect exact canonical digest for same_content_new_run_attempt_acquisition", + "category": "nine_preimages", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_canonical_vector_1", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(inventory_sha256(case[\"core\"]), 'c507727b90f939d5aad3a4eff41868ab84c8cb6bcb972b3c76be3ea00186fa8a')", + "line": 401, + "operation": "assertEqual" + } + ], + "break_caught": "Incorrect exact canonical digest for actual_type_record_change", + "category": "nine_preimages", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_canonical_vector_2", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(inventory_sha256(case[\"core\"]), '5ff478abe3a20e67de8ec879e8a91930256dab1a68c8ea04263bc1296c59c4f3')", + "line": 405, + "operation": "assertEqual" + } + ], + "break_caught": "Incorrect exact canonical digest for actual_compiler_option_change", + "category": "nine_preimages", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_canonical_vector_3", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(inventory_sha256(case[\"core\"]), 'ed156dc4afac2484f25ef5ec797258d72295a787f9fb642b913fa7854a34152e')", + "line": 409, + "operation": "assertEqual" + } + ], + "break_caught": "Incorrect exact canonical digest for actual_dependency_change", + "category": "nine_preimages", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_canonical_vector_4", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(inventory_sha256(case[\"core\"]), '01127aa13ad6f9e145489e5ceaff15426926637de8245e98b11e8953de6820dd')", + "line": 413, + "operation": "assertEqual" + } + ], + "break_caught": "Incorrect exact canonical digest for actual_scope_change", + "category": "nine_preimages", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_canonical_vector_5", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(inventory_sha256(case[\"core\"]), '1e79cef0d148509119876ed49ab75d86bee2e0640b31be80e74ca2ef38a4cfc6')", + "line": 417, + "operation": "assertEqual" + } + ], + "break_caught": "Incorrect exact canonical digest for accepted_proof_body_only_module_edit_plus_manifest_refresh", + "category": "nine_preimages", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_canonical_vector_6", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(inventory_sha256(case[\"core\"]), '364dc7d33c64bc68faf197b77e1abbdd8cd4ea0472c44f67712d5dd58a9dadb1')", + "line": 421, + "operation": "assertEqual" + } + ], + "break_caught": "Incorrect exact canonical digest for selector_only_change_same_source_and_type", + "category": "nine_preimages", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_canonical_vector_7", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(inventory_sha256(case[\"core\"]), 'ebf1d7f9ed021c8724d19f4320f2f271fbd77bc490f68720fb3ab11817e8fbed')", + "line": 425, + "operation": "assertEqual" + } + ], + "break_caught": "Incorrect exact canonical digest for same_module_edit_missing_proof_selector", + "category": "nine_preimages", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_canonical_vector_8", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Null image manifest accepted outside explicitly admitted nonimage profile", + "category": "runtime_null_qualification", + "contract_basis": "DATA closed_types / lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "helper_assertions": [ + "collection_refusal: pristine complete fixture joins and exact product diagnostic baseline first; mutate one declared condition; formal None plus specific sorted diagnostic reason; no unrelated failure earns refusal credit" + ], + "id": "test_formal_regression.ContractControls.test_collection_nonimage_null_does_not_admit_image_runtime", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Collection boundary accepts ambiguous_enumeration", + "category": "native_enumeration", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "helper_assertions": [ + "collection_refusal: pristine complete fixture joins and exact product diagnostic baseline first; mutate one declared condition; formal None plus specific sorted diagnostic reason; no unrelated failure earns refusal credit" + ], + "id": "test_formal_regression.ContractControls.test_collection_refuses_ambiguous_enumeration", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Collection boundary accepts duplicate_native_record", + "category": "identity", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "helper_assertions": [ + "collection_refusal: pristine complete fixture joins and exact product diagnostic baseline first; mutate one declared condition; formal None plus specific sorted diagnostic reason; no unrelated failure earns refusal credit" + ], + "id": "test_formal_regression.ContractControls.test_collection_refuses_duplicate_native_record", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Collection boundary accepts foreign_native_target", + "category": "foreign_target", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "helper_assertions": [ + "collection_refusal: pristine complete fixture joins and exact product diagnostic baseline first; mutate one declared condition; formal None plus specific sorted diagnostic reason; no unrelated failure earns refusal credit" + ], + "id": "test_formal_regression.ContractControls.test_collection_refuses_foreign_native_target", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Collection boundary accepts foreign_selector_link", + "category": "selector_link_identity", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "helper_assertions": [ + "collection_refusal: pristine complete fixture joins and exact product diagnostic baseline first; mutate one declared condition; formal None plus specific sorted diagnostic reason; no unrelated failure earns refusal credit" + ], + "id": "test_formal_regression.ContractControls.test_collection_refuses_foreign_selector_link", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Collection boundary accepts missing_enumeration", + "category": "native_enumeration", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "helper_assertions": [ + "collection_refusal: pristine complete fixture joins and exact product diagnostic baseline first; mutate one declared condition; formal None plus specific sorted diagnostic reason; no unrelated failure earns refusal credit" + ], + "id": "test_formal_regression.ContractControls.test_collection_refuses_missing_enumeration", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Collection boundary accepts omitted_build_role", + "category": "build_complete", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "helper_assertions": [ + "collection_refusal: pristine complete fixture joins and exact product diagnostic baseline first; mutate one declared condition; formal None plus specific sorted diagnostic reason; no unrelated failure earns refusal credit" + ], + "id": "test_formal_regression.ContractControls.test_collection_refuses_omitted_build_role", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Collection boundary accepts omitted_dependency", + "category": "dependency_complete", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "helper_assertions": [ + "collection_refusal: pristine complete fixture joins and exact product diagnostic baseline first; mutate one declared condition; formal None plus specific sorted diagnostic reason; no unrelated failure earns refusal credit" + ], + "id": "test_formal_regression.ContractControls.test_collection_refuses_omitted_dependency", + "normal_and_optimized": true, + "proposed_boundary_decision": true, + "r01_additive_subtests": "Additional assertions/subtests inside this unchanged explicit method ID; full source is normative." + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Collection boundary accepts omitted_import_role", + "category": "imports_complete", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "helper_assertions": [ + "collection_refusal: pristine complete fixture joins and exact product diagnostic baseline first; mutate one declared condition; formal None plus specific sorted diagnostic reason; no unrelated failure earns refusal credit" + ], + "id": "test_formal_regression.ContractControls.test_collection_refuses_omitted_import_role", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Collection boundary accepts omitted_native_target", + "category": "full_inventory", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "helper_assertions": [ + "collection_refusal: pristine complete fixture joins and exact product diagnostic baseline first; mutate one declared condition; formal None plus specific sorted diagnostic reason; no unrelated failure earns refusal credit" + ], + "id": "test_formal_regression.ContractControls.test_collection_refuses_omitted_native_target", + "normal_and_optimized": true, + "proposed_boundary_decision": true, + "r01_additive_subtests": "Additional assertions/subtests inside this unchanged explicit method ID; full source is normative." + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Collection boundary accepts omitted_producer_role", + "category": "producer_complete", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "helper_assertions": [ + "collection_refusal: pristine complete fixture joins and exact product diagnostic baseline first; mutate one declared condition; formal None plus specific sorted diagnostic reason; no unrelated failure earns refusal credit" + ], + "id": "test_formal_regression.ContractControls.test_collection_refuses_omitted_producer_role", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Collection boundary accepts omitted_scope_role", + "category": "source_roles", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "helper_assertions": [ + "collection_refusal: pristine complete fixture joins and exact product diagnostic baseline first; mutate one declared condition; formal None plus specific sorted diagnostic reason; no unrelated failure earns refusal credit" + ], + "id": "test_formal_regression.ContractControls.test_collection_refuses_omitted_scope_role", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Collection boundary accepts origin_relabelled_snapshot", + "category": "origin_snapshot", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "helper_assertions": [ + "collection_refusal: pristine complete fixture joins and exact product diagnostic baseline first; mutate one declared condition; formal None plus specific sorted diagnostic reason; no unrelated failure earns refusal credit" + ], + "id": "test_formal_regression.ContractControls.test_collection_refuses_origin_relabelled_snapshot", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assert_collection_baseline(self.collection())", + "line": 896, + "operation": "assert_collection_baseline" + }, + { + "expression": "self.assertIsNone(result[\"formal_inventory_sha256\"])", + "line": 901, + "operation": "assertIsNone" + }, + { + "expression": "self.assertEqual(result[\"issues\"], sorted(set(result[\"issues\"])))", + "line": 902, + "operation": "assertEqual" + }, + { + "expression": "self.assertIn(reason, result[\"issues\"])", + "line": 904, + "operation": "assertIn" + } + ], + "break_caught": "Collection boundary accepts raw_source_digest_mismatch", + "category": "source_raw_bytes", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "helper_assertions": [ + "collection_refusal: pristine complete fixture joins and exact product diagnostic baseline first; mutate one declared condition; formal None plus specific sorted diagnostic reason; no unrelated failure earns refusal credit" + ], + "id": "test_formal_regression.ContractControls.test_collection_refuses_raw_source_digest_mismatch", + "normal_and_optimized": true, + "proposed_boundary_decision": true, + "r01_additive_subtests": "Additional assertions/subtests inside this unchanged explicit method ID; full source is normative." + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Accepted-looking selector digest not checked against exact raw source slice", + "category": "selector_raw_bytes", + "contract_basis": "DATA closed_types / lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "helper_assertions": [ + "collection_refusal: pristine complete fixture joins and exact product diagnostic baseline first; mutate one declared condition; formal None plus specific sorted diagnostic reason; no unrelated failure earns refusal credit" + ], + "id": "test_formal_regression.ContractControls.test_collection_refuses_selector_raw_slice_mismatch", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Collection boundary accepts snapshot_source_wrong_commit", + "category": "source_membership", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "helper_assertions": [ + "collection_refusal: pristine complete fixture joins and exact product diagnostic baseline first; mutate one declared condition; formal None plus specific sorted diagnostic reason; no unrelated failure earns refusal credit" + ], + "id": "test_formal_regression.ContractControls.test_collection_refuses_snapshot_source_wrong_commit", + "normal_and_optimized": true, + "proposed_boundary_decision": true, + "r01_additive_subtests": "Additional assertions/subtests inside this unchanged explicit method ID; full source is normative." + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Collection boundary accepts unknown_enumeration", + "category": "native_enumeration", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "helper_assertions": [ + "collection_refusal: pristine complete fixture joins and exact product diagnostic baseline first; mutate one declared condition; formal None plus specific sorted diagnostic reason; no unrelated failure earns refusal credit" + ], + "id": "test_formal_regression.ContractControls.test_collection_refuses_unknown_enumeration", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Collection boundary accepts unknown_selector_acceptance", + "category": "selector_authority", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "helper_assertions": [ + "collection_refusal: pristine complete fixture joins and exact product diagnostic baseline first; mutate one declared condition; formal None plus specific sorted diagnostic reason; no unrelated failure earns refusal credit" + ], + "id": "test_formal_regression.ContractControls.test_collection_refuses_unknown_selector_acceptance", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Collection boundary accepts unsupported_native_format", + "category": "native_enumeration", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "helper_assertions": [ + "collection_refusal: pristine complete fixture joins and exact product diagnostic baseline first; mutate one declared condition; formal None plus specific sorted diagnostic reason; no unrelated failure earns refusal credit" + ], + "id": "test_formal_regression.ContractControls.test_collection_refuses_unsupported_native_format", + "normal_and_optimized": true, + "proposed_boundary_decision": true, + "r01_additive_subtests": "Additional assertions/subtests inside this unchanged explicit method ID; full source is normative." + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertIsNone(result[\"core\"])", + "line": 908, + "operation": "assertIsNone" + }, + { + "expression": "self.assertIsNone(result[\"formal_inventory_sha256\"])", + "line": 909, + "operation": "assertIsNone" + }, + { + "expression": "self.assertIsNone(result[\"diagnostic_inventory_sha256\"])", + "line": 910, + "operation": "assertIsNone" + }, + { + "expression": "self.assertIn(\"NATIVE_ENUMERATION_UNRESOLVED\", result[\"issues\"])", + "line": 911, + "operation": "assertIn" + } + ], + "break_caught": "Incomplete enumeration produces empty or subset replacement core", + "category": "no_subset_fallback", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "id": "test_formal_regression.ContractControls.test_collection_unknown_enumeration_has_no_core", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertIsNone(result[\"formal_inventory_sha256\"])", + "line": 1049, + "operation": "assertIsNone" + }, + { + "expression": "self.assertIsNotNone(result[\"diagnostic_inventory_sha256\"])", + "line": 1050, + "operation": "assertIsNotNone" + }, + { + "expression": "self.assertEqual(result[\"core\"][\"targets\"][0][\"accepted_formal_statement_selector\"], [])", + "line": 1051, + "operation": "assertEqual" + }, + { + "expression": "self.assertEqual(result[\"core\"][\"targets\"][0][\"accepted_formal_proof_selector\"], [])", + "line": 1052, + "operation": "assertEqual" + }, + { + "expression": "self.assert_collection_baseline(self.collection())", + "line": 1054, + "operation": "assert_collection_baseline" + }, + { + "expression": "self.assertEqual([target[\"target\"] for target in result[\"core\"][\"targets\"]], [\"Demo.t\", \"Demo.unlinked\"])", + "line": 1055, + "operation": "assertEqual" + }, + { + "expression": "self.assertEqual(target[\"accepted_formal_statement_selector\"], [])", + "line": 1057, + "operation": "assertEqual" + }, + { + "expression": "self.assertEqual(target[\"accepted_formal_proof_selector\"], [])", + "line": 1058, + "operation": "assertEqual" + }, + { + "expression": "self.assertEqual(target[\"unresolved_fields\"], [\"type_content_bytes\", \"type_content_sha256\"])", + "line": 1059, + "operation": "assertEqual" + } + ], + "break_caught": "Known zero-link set confused with unknown acceptance or silently fabricated link", + "category": "known_zero_links", + "contract_basis": "DATA closed_types / lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "id": "test_formal_regression.ContractControls.test_collection_zero_links_is_known_absence_diagnostic", + "normal_and_optimized": true, + "proposed_boundary_decision": true, + "r01_additive_subtests": "Additional assertions/subtests inside this unchanged explicit method ID; full source is normative." + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Actual compiler binary/version identities omitted", + "category": "compiler_bytes", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_compiler_binary_and_version_content_closed", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Compiler/options/dependency/build/runtime source field omitted", + "category": "closed_compiler_dependency", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_compiler_dependency_content_closed", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 998, + "operation": "assertRaises" + } + ], + "break_caught": "Conflicting rows with same canonical native identity accepted", + "category": "identity_conflict", + "contract_basis": "DATA closed_types / lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_conflicting_duplicate_target_identity_refuses", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assert_collection_baseline(self.collection())", + "line": 1070, + "operation": "assert_collection_baseline" + }, + { + "expression": "self.assert_collection_baseline(projected)", + "line": 1072, + "operation": "assert_collection_baseline" + } + ], + "break_caught": "Noncanonical dependency/executable ordering generates multiple digests for the same content", + "category": "canonical_array_order", + "contract_basis": "DATA closed_types / lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_dependency_and_runtime_arrays_require_canonical_order", + "normal_and_optimized": true, + "proposed_boundary_decision": true, + "r01_additive_subtests": "Additional assertions/subtests inside this unchanged explicit method ID; full source is normative." + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Duplicate dependency or shortened revision accepted", + "category": "dependency_identity", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_dependency_names_unique_and_revisions_full", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 388, + "operation": "assertRaises" + } + ], + "break_caught": "Byte-identical duplicate target accepted", + "category": "identity", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_duplicate_identity_refuses", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Duplicate/conflicting source path within role accepted", + "category": "source_role_duplicate", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_duplicate_source_role_paths_refuse", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Boolean accepted as byte count or selector offset", + "category": "exact_integer", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_exact_integer_excludes_boolean", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(len(self.vectors[\"cases\"]), 9)", + "line": 428, + "operation": "assertEqual" + }, + { + "expression": "self.assert_held_profile(self.profile)", + "line": 435, + "operation": "assert_held_profile" + }, + { + "expression": "self.assertNotEqual(oracles[0][\"commit\"], oracles[1][\"commit\"])", + "line": 437, + "operation": "assertNotEqual" + }, + { + "expression": "self.assertNotEqual(oracles[0][\"canonical_ascii_preimage\"], oracles[1][\"canonical_ascii_preimage\"])", + "line": 438, + "operation": "assertNotEqual" + }, + { + "expression": "self.assertEqual(len(raw), oracle[\"bytes\"])", + "line": 441, + "operation": "assertEqual" + }, + { + "expression": "self.assertEqual(hashlib.sha256(raw).hexdigest(), oracle[\"sha256\"])", + "line": 442, + "operation": "assertEqual" + }, + { + "expression": "self.assertEqual(wire(case[\"core\"]), raw)", + "line": 432, + "operation": "assertEqual" + }, + { + "expression": "self.assertEqual(hashlib.sha256(raw).hexdigest(), case[\"sha256\"])", + "line": 433, + "operation": "assertEqual" + } + ], + "break_caught": "Fixture corruption or mismatch between exact independent preimage and expected hash", + "category": "held_fixture_positive", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "PASS", + "expected_scaffold_failure_kind": "held independent fixture integrity positive", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "id": "test_formal_regression.ContractControls.test_fixture_preimages_are_independent", + "normal_and_optimized": true, + "proposed_boundary_decision": false, + "r01_additive_subtests": "Additional assertions/subtests inside this unchanged explicit method ID; full source is normative." + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Target module incorrectly included as its own imported source", + "category": "imports_complete", + "contract_basis": "DATA formal_inventory_hash_contract closed nested forms / one_formula", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_import_set_excludes_target_module", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(inventory_sha256(core), '4a469c57ba103d8937795c709b59765a689ae24f92b6ee1d55ddc74037b849e6')", + "line": 358, + "operation": "assertEqual" + } + ], + "break_caught": "Wrong hash formula, wrapper, whitespace, normalization or constant empty digest", + "category": "canonical_baseline", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_inventory_baseline_hash", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Missing/extra root fields accepted", + "category": "closed_inventory_root", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_inventory_root_is_closed", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Empty/invalid identity or empty native subset accepted", + "category": "inventory_identity", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_inventory_root_types_and_domain", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Unknown native enumeration format creates accepted digest", + "category": "supported_format", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_native_format_is_supported", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Unknown native identity kept inside a diagnostic core", + "category": "identity_required", + "contract_basis": "DATA closed_types / lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_native_identity_cannot_be_unresolved", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Negative/fraction/string byte count coerced", + "category": "numeric_types", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_negative_or_fractional_sizes_refuse", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Unknown fields accepted in ByteContent/compiler/runtime/named-executable/selector nested forms", + "category": "closed_all_nested", + "contract_basis": "DATA formal_inventory_hash_contract closed nested forms / one_formula", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_nested_compiler_runtime_and_selector_extra_fields_refuse", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(inventory_sha256(self.core()), BASELINE)", + "line": 988, + "operation": "assertEqual" + }, + { + "expression": "self.assertNotEqual(inventory_sha256(known_absent), BASELINE)", + "line": 989, + "operation": "assertNotEqual" + } + ], + "break_caught": "Known null selector confused with omitted accepted link", + "category": "known_absence", + "contract_basis": "DATA formal_inventory_hash_contract closed nested forms / one_formula", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_null_and_empty_selectors_are_distinct", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Options filtered/coerced or wrong print type admitted", + "category": "options_types", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_options_remain_ordered_strings", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(inventory_sha256(core), 'ec5c0464eb3b3ac437c8309d5a9b182530eae67547689a5c05579281268d136d')", + "line": 975, + "operation": "assertEqual" + }, + { + "expression": "self.assertNotEqual(first_core, core)", + "line": 978, + "operation": "assertNotEqual" + }, + { + "expression": "self.assertNotEqual(wire(first_core), wire(core))", + "line": 979, + "operation": "assertNotEqual" + }, + { + "expression": "self.assertEqual(first_core[\"targets\"][0][\"compiler_dependency_options_identity\"][\"producer_sources\"][0][\"ref\"][\"commit\"], \"7\" * 40)", + "line": 980, + "operation": "assertEqual" + }, + { + "expression": "self.assertEqual(core[\"targets\"][0][\"compiler_dependency_options_identity\"][\"producer_sources\"][0][\"ref\"][\"commit\"], \"8\" * 40)", + "line": 981, + "operation": "assertEqual" + }, + { + "expression": "self.assertEqual(inventory_sha256(core), 'c0df40e646762921112000930d9dae597ef08bd8e03f361dd9f0a6de5b34fe99')", + "line": 982, + "operation": "assertEqual" + } + ], + "break_caught": "Immutable origin commits 7*40 and 8*40 are truly distinct; exact independently derived canonical preimages/hashes and explicit real-mutation assertions prevent contradictory oracle or normalization.", + "category": "origin_commit", + "contract_basis": "DATA formal_inventory_hash_contract closed nested forms / one_formula", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_origin_commit_remains_in_content_digest", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 747, + "operation": "assertRaises" + } + ], + "break_caught": "Fixed origin drops immutable commit or other full identity", + "category": "origin_closed", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_origin_requires_all_six_full_ref_fields", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Unsafe or incomplete native package identity accepted", + "category": "package_identity", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_package_identity_closed_and_safe", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 680, + "operation": "assertRaises" + } + ], + "break_caught": "Boolean used as policy schema integer", + "category": "policy_types", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_policy_boolean_version_refuses", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 629, + "operation": "assertRaises" + }, + { + "expression": "self.assertRaises(ValueError)", + "line": 648, + "operation": "assertRaises" + }, + { + "expression": "self.assertRaises(ValueError)", + "line": 644, + "operation": "assertRaises" + } + ], + "break_caught": "Missing Policy field silently defaulted", + "category": "closed_policy", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "id": "test_formal_regression.ContractControls.test_policy_closed_field_set", + "normal_and_optimized": true, + "proposed_boundary_decision": true, + "r01_additive_subtests": "Additional assertions/subtests inside this unchanged explicit method ID; full source is normative." + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(decode_policy(raw, hashlib.sha256(raw).hexdigest()), expected)", + "line": 612, + "operation": "assertEqual" + } + ], + "break_caught": "Empty/coerced policy or no pin consumption", + "category": "policy_positive", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_policy_decode_uses_exact_raw_pin", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaisesRegex(ValueError, '(?i)depth')", + "line": 668, + "operation": "assertRaisesRegex" + } + ], + "break_caught": "Strict policy parser accepts depth", + "category": "strict_policy_depth", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_policy_refuses_depth", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaisesRegex(ValueError, \"(?i)duplicat\")", + "line": 653, + "operation": "assertRaisesRegex" + } + ], + "break_caught": "Strict policy parser accepts duplicate", + "category": "strict_policy_duplicate", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_policy_refuses_duplicate", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 1025, + "operation": "assertRaises" + } + ], + "break_caught": "Extra Policy field accepted", + "category": "closed_policy", + "contract_basis": "DATA closed_types / lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_policy_refuses_extra_field", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaisesRegex(ValueError, '(?i)(finite|nan|infinity)')", + "line": 663, + "operation": "assertRaisesRegex" + } + ], + "break_caught": "Strict policy parser accepts nonfinite", + "category": "strict_policy_nonfinite", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_policy_refuses_nonfinite", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaisesRegex(ValueError, '(?i)(size|limit|large)')", + "line": 673, + "operation": "assertRaisesRegex" + } + ], + "break_caught": "Strict policy parser accepts oversize", + "category": "strict_policy_oversize", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_policy_refuses_oversize", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaisesRegex(ValueError, '(?i)(trailing|extra data)')", + "line": 658, + "operation": "assertRaisesRegex" + } + ], + "break_caught": "Strict policy parser accepts trailing", + "category": "strict_policy_trailing", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_policy_refuses_trailing", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 621, + "operation": "assertRaises" + } + ], + "break_caught": "Policy pin normalized rather than raw-byte checked", + "category": "policy_pin_raw", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_policy_whitespace_is_part_of_raw_pin", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 616, + "operation": "assertRaises" + } + ], + "break_caught": "Wrong independently supplied policy digest accepted", + "category": "policy_pin", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_policy_wrong_raw_pin_refuses", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(inventory_sha256(core), '949c0173ab4ac0fef66a8f04de8c2323cafa4453d8dbbfd7ffd512119ddda5c1')", + "line": 958, + "operation": "assertEqual" + }, + { + "expression": "self.assertEqual(inventory_sha256(core), '952e41e8e233ea47b2d4414346ecac97cac1fa8a48485ccef8e7ae7966278249')", + "line": 960, + "operation": "assertEqual" + }, + { + "expression": "self.assert_collection_baseline(original)", + "line": 963, + "operation": "assert_collection_baseline" + }, + { + "expression": "self.assertEqual(changed[\"core\"][\"targets\"][0][\"compiler_dependency_options_identity\"][\"print_options\"], list(reversed(self.profile[\"membership\"][\"producer_observation\"][\"print_options\"])))", + "line": 965, + "operation": "assertEqual" + }, + { + "expression": "self.assertNotEqual(changed[\"diagnostic_inventory_sha256\"], original[\"diagnostic_inventory_sha256\"])", + "line": 966, + "operation": "assertNotEqual" + }, + { + "expression": "self.assertEqual(changed[\"diagnostic_inventory_sha256\"], self.profile[\"projection_order_oracles\"][\"print_options\"][\"sha256\"])", + "line": 967, + "operation": "assertEqual" + }, + { + "expression": "self.assertEqual(wire(changed[\"core\"]), self.profile[\"projection_order_oracles\"][\"print_options\"][\"canonical_ascii_preimage\"].encode(\"ascii\"))", + "line": 968, + "operation": "assertEqual" + }, + { + "expression": "self.assertIsNone(changed[\"formal_inventory_sha256\"])", + "line": 969, + "operation": "assertIsNone" + } + ], + "break_caught": "Ordered semantic/type-print options dropped or sorted", + "category": "ordered_options", + "contract_basis": "DATA formal_inventory_hash_contract closed nested forms / one_formula", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "id": "test_formal_regression.ContractControls.test_print_options_order_changes_digest", + "normal_and_optimized": true, + "proposed_boundary_decision": false, + "r01_additive_subtests": "Additional assertions/subtests inside this unchanged explicit method ID; full source is normative." + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(inventory_sha256(first_core), inventory_sha256(second_core))", + "line": 363, + "operation": "assertEqual" + }, + { + "expression": "self.assertEqual(inventory_sha256(first_core), BASELINE)", + "line": 364, + "operation": "assertEqual" + } + ], + "break_caught": "Run/attempt/acquisition data contaminates content digest; anchored hash also catches constant empty output", + "category": "recollection", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_recollection_keeps_content_digest", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Same repository/path has contradictory content across roles", + "category": "source_role_consistency", + "contract_basis": "DATA formal_inventory_hash_contract closed nested forms / one_formula", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_repeated_source_roles_cannot_disagree", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 1035, + "operation": "assertRaises" + } + ], + "break_caught": "Malformed/Boolean commit or tree is accepted/coerced", + "category": "commit_types", + "contract_basis": "DATA closed_types / lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_commit_and_tree_are_full_lowercase_hashes", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 606, + "operation": "assertRaises" + } + ], + "break_caught": "Partial B/H/S/T CommitRef accepted", + "category": "closed_commitref", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_commit_refs_are_closed", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(decode_request(wire(expected)), expected)", + "line": 446, + "operation": "assertEqual" + } + ], + "break_caught": "Decoder returns empty/default/coerced context", + "category": "request_positive", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_decode_roundtrip", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(baseline, 'ac1cffe262a84ab7fb9ee3eece0d93b2a3e0b89b00a7ff1c9d747b9aa5abbd8d')", + "line": 453, + "operation": "assertEqual" + }, + { + "expression": "self.assertNotEqual(request_key(changed), baseline)", + "line": 465, + "operation": "assertNotEqual" + }, + { + "expression": "self.assertNotEqual(request_key(changed), baseline)", + "line": 462, + "operation": "assertNotEqual" + } + ], + "break_caught": "B/H/S/T/P excluded or conflated", + "category": "request_freshness", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_key_changes_each_source_identity", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(request_key(self.request()), 'ac1cffe262a84ab7fb9ee3eece0d93b2a3e0b89b00a7ff1c9d747b9aa5abbd8d')", + "line": 449, + "operation": "assertEqual" + } + ], + "break_caught": "Wrong request domain/context/full B/H/S/T/P projection", + "category": "request_key", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_key_exact_domain_formula", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 470, + "operation": "assertRaises" + } + ], + "break_caught": "Unbounded acquisition field accepted in stable context", + "category": "closed_request", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_key_refuses_acquisition_fields", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 514, + "operation": "assertRaises" + } + ], + "break_caught": "Request decoder accepts bom", + "category": "strict_json_bom", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_refuses_bom", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 551, + "operation": "assertRaises" + } + ], + "break_caught": "Type coercion or unsupported request context accepted", + "category": "request_types", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_refuses_boolean_native_id", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 545, + "operation": "assertRaises" + } + ], + "break_caught": "Type coercion or unsupported request context accepted", + "category": "request_types", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_refuses_boolean_version", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaisesRegex(ValueError, '(?i)depth')", + "line": 519, + "operation": "assertRaisesRegex" + } + ], + "break_caught": "Request decoder accepts depth_over_64", + "category": "strict_json_depth_over_64", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_refuses_depth_over_64", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaisesRegex(ValueError, '(?i)duplicat')", + "line": 480, + "operation": "assertRaisesRegex" + } + ], + "break_caught": "Request decoder accepts duplicate_nested_key", + "category": "strict_json_duplicate_nested_key", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_refuses_duplicate_nested_key", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaisesRegex(ValueError, \"(?i)duplicat\")", + "line": 475, + "operation": "assertRaisesRegex" + } + ], + "break_caught": "Request decoder accepts duplicate_top_key", + "category": "strict_json_duplicate_top_key", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_refuses_duplicate_top_key", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 575, + "operation": "assertRaises" + } + ], + "break_caught": "Type coercion or unsupported request context accepted", + "category": "request_types", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_refuses_head_fallback", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 557, + "operation": "assertRaises" + } + ], + "break_caught": "Type coercion or unsupported request context accepted", + "category": "request_types", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_refuses_integer_native_id", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 509, + "operation": "assertRaises" + } + ], + "break_caught": "Request decoder accepts invalid_utf8", + "category": "strict_json_invalid_utf8", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_refuses_invalid_utf8", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 592, + "operation": "assertRaises" + }, + { + "expression": "self.assertRaises(ValueError)", + "line": 588, + "operation": "assertRaises" + } + ], + "break_caught": "Missing/extra RequestContext fields accepted", + "category": "closed_request", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_refuses_missing_and_extra_fields", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 563, + "operation": "assertRaises" + } + ], + "break_caught": "Type coercion or unsupported request context accepted", + "category": "request_types", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_refuses_noncanonical_native_id", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaisesRegex(ValueError, '(?i)(finite|nan|infinity)')", + "line": 495, + "operation": "assertRaisesRegex" + }, + { + "expression": "self.assertRaisesRegex(ValueError, '(?i)(finite|nan|infinity)')", + "line": 499, + "operation": "assertRaisesRegex" + } + ], + "break_caught": "Request decoder accepts nonfinite_infinity", + "category": "strict_json_nonfinite_infinity", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "id": "test_formal_regression.ContractControls.test_request_refuses_nonfinite_infinity", + "normal_and_optimized": true, + "proposed_boundary_decision": false, + "r01_additive_subtests": "Additional assertions/subtests inside this unchanged explicit method ID; full source is normative." + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaisesRegex(ValueError, '(?i)(finite|nan|infinity)')", + "line": 490, + "operation": "assertRaisesRegex" + } + ], + "break_caught": "Request decoder accepts nonfinite_nan", + "category": "strict_json_nonfinite_nan", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_refuses_nonfinite_nan", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaisesRegex(ValueError, '(?i)(finite|nan|infinity)')", + "line": 504, + "operation": "assertRaisesRegex" + } + ], + "break_caught": "Request decoder accepts nonfinite_negative_infinity", + "category": "strict_json_nonfinite_negative_infinity", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_refuses_nonfinite_negative_infinity", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaisesRegex(ValueError, '(?i)(size|limit|large)')", + "line": 524, + "operation": "assertRaisesRegex" + } + ], + "break_caught": "Request decoder accepts oversize", + "category": "strict_json_oversize", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_refuses_oversize", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 539, + "operation": "assertRaises" + } + ], + "break_caught": "Request decoder accepts raw_bytearray", + "category": "strict_json_raw_bytearray", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_refuses_raw_bytearray", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 534, + "operation": "assertRaises" + } + ], + "break_caught": "Request decoder accepts raw_str", + "category": "strict_json_raw_str", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_refuses_raw_str", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 581, + "operation": "assertRaises" + } + ], + "break_caught": "Type coercion or unsupported request context accepted", + "category": "request_types", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_refuses_supplied_url", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaisesRegex(ValueError, '(?i)(trailing|extra data)')", + "line": 485, + "operation": "assertRaisesRegex" + } + ], + "break_caught": "Request decoder accepts trailing_value", + "category": "strict_json_trailing_value", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_refuses_trailing_value", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 569, + "operation": "assertRaises" + } + ], + "break_caught": "Type coercion or unsupported request context accepted", + "category": "request_types", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_refuses_uppercase_digest", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 598, + "operation": "assertRaises" + } + ], + "break_caught": "B/H order or H=S substitution accepted", + "category": "request_parent_order", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_refuses_wrong_merge_parents", + "normal_and_optimized": true, + "proposed_boundary_decision": true + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertRaises(ValueError)", + "line": 529, + "operation": "assertRaises" + } + ], + "break_caught": "Request decoder accepts wrong_root_type", + "category": "strict_json_wrong_root_type", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_request_refuses_wrong_root_type", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Required unavailable content silently promoted to formal completeness", + "category": "required_null", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_required_null_needs_exact_unresolved_name", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Half-null type or missing unresolved declaration accepted", + "category": "paired_type_null", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_required_type_null_pair_cannot_be_half_known", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Empty executable/platform or unavailable executable content treated as complete", + "category": "runtime_complete", + "contract_basis": "DATA closed_types / lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_runtime_executable_is_complete_nonempty_named_content", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Duplicate named executable accepted", + "category": "runtime_duplicate", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_runtime_executable_names_unique", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Missing platform/image/executable identity accepted", + "category": "closed_runtime", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_runtime_identity_closed", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Scope/import role type silently coerced", + "category": "scope_types", + "contract_basis": "DATA closed_types / lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_scope_and_import_role_values_are_arrays", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Absent scope set or unknown import set treated as complete empty", + "category": "closed_scope_import", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_scope_and_import_sets_closed", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Empty/reversed/out-of-range/Boolean selector accepted", + "category": "selector_bounds", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_selector_bounds_are_exact", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Incomplete link or source slice identity accepted", + "category": "closed_selector", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_selector_entry_and_slice_closed", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Mismatched/doubled/omitted accepted link set accepted", + "category": "selector_link_identity", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_selector_link_sets_complete_and_unique", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(inventory_sha256(core), '219b9a536edc8447353206a5b4ccece855746c741e2f65dfecf070718854e4e1')", + "line": 941, + "operation": "assertEqual" + }, + { + "expression": "self.assertEqual(inventory_sha256(core), '94a083534fc885a6d94ca22880a5fd760c5e28533ef6e864d13e7bb445f6c88d')", + "line": 943, + "operation": "assertEqual" + }, + { + "expression": "self.assert_collection_baseline(original)", + "line": 946, + "operation": "assert_collection_baseline" + }, + { + "expression": "self.assertEqual(changed[\"core\"][\"targets\"][0][\"compiler_dependency_options_identity\"][\"options\"], list(reversed(self.profile[\"membership\"][\"producer_observation\"][\"options\"])))", + "line": 948, + "operation": "assertEqual" + }, + { + "expression": "self.assertNotEqual(changed[\"diagnostic_inventory_sha256\"], original[\"diagnostic_inventory_sha256\"])", + "line": 949, + "operation": "assertNotEqual" + }, + { + "expression": "self.assertEqual(changed[\"diagnostic_inventory_sha256\"], self.profile[\"projection_order_oracles\"][\"options\"][\"sha256\"])", + "line": 950, + "operation": "assertEqual" + }, + { + "expression": "self.assertEqual(wire(changed[\"core\"]), self.profile[\"projection_order_oracles\"][\"options\"][\"canonical_ascii_preimage\"].encode(\"ascii\"))", + "line": 951, + "operation": "assertEqual" + }, + { + "expression": "self.assertIsNone(changed[\"formal_inventory_sha256\"])", + "line": 952, + "operation": "assertIsNone" + } + ], + "break_caught": "Ordered semantic/type-print options dropped or sorted", + "category": "ordered_options", + "contract_basis": "DATA formal_inventory_hash_contract closed nested forms / one_formula", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "id": "test_formal_regression.ContractControls.test_semantic_options_order_changes_digest", + "normal_and_optimized": true, + "proposed_boundary_decision": false, + "r01_additive_subtests": "Additional assertions/subtests inside this unchanged explicit method ID; full source is normative." + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(len(set(changed_hashes)), 7)", + "line": 369, + "operation": "assertEqual" + }, + { + "expression": "self.assertNotIn(baseline_hash, changed_hashes)", + "line": 370, + "operation": "assertNotIn" + } + ], + "break_caught": "Dropping any of seven type/compiler/dependency/scope/proof/selector/unscoped content deltas", + "category": "seven_deltas", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "id": "test_formal_regression.ContractControls.test_seven_content_deltas", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Incomplete source content or leaked snapshot commit accepted", + "category": "snapshot_closed", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_snapshot_source_has_exact_six_content_fields", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Noncanonical or truncated hash accepted", + "category": "source_hash_types", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_source_hashes_are_canonical", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Unsafe source path accepted", + "category": "source_path", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_source_paths_refuse_escape_absolute_and_url", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual(projected[\"core\"], self.profile[\"expected_diagnostic_core\"])", + "line": 1083, + "operation": "assertEqual" + }, + { + "expression": "self.assertEqual(projected[\"diagnostic_inventory_sha256\"], self.profile[\"expected_diagnostic_sha256\"])", + "line": 1084, + "operation": "assertEqual" + } + ], + "break_caught": "Noncanonical source role ordering accepted at canonical-core boundary", + "category": "canonical_source_order", + "contract_basis": "DATA closed_types / lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_source_role_arrays_require_canonical_order", + "normal_and_optimized": true, + "proposed_boundary_decision": true, + "r01_additive_subtests": "Additional assertions/subtests inside this unchanged explicit method ID; full source is normative." + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Duplicate source identity accepted in any build/producer/import role", + "category": "source_role_unique", + "contract_basis": "DATA formal_inventory_hash_contract closed nested forms / one_formula", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_source_role_lists_have_unique_canonical_identity", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertEqual([target[\"target\"] for target in projected[\"core\"][\"targets\"]], [\"Demo.t\", \"Demo.unlinked\"])", + "line": 1096, + "operation": "assertEqual" + }, + { + "expression": "self.assertRaises(ValueError)", + "line": 1092, + "operation": "assertRaises" + } + ], + "break_caught": "Unsorted canonical target identities accepted at hash boundary", + "category": "canonical_target_order", + "contract_basis": "DATA closed_types / lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "id": "test_formal_regression.ContractControls.test_target_array_requires_canonical_identity_order", + "normal_and_optimized": true, + "proposed_boundary_decision": true, + "r01_additive_subtests": "Additional assertions/subtests inside this unchanged explicit method ID; full source is normative." + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Run/acquisition data allowed in canonical semantic target", + "category": "volatile_exclusion", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_target_unknown_field_refuses", + "normal_and_optimized": true, + "proposed_boundary_decision": false + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [ + { + "expression": "self.assertIsNone(result[\"formal_inventory_sha256\"])", + "line": 374, + "operation": "assertIsNone" + }, + { + "expression": "self.assertIsNotNone(result[\"diagnostic_inventory_sha256\"])", + "line": 375, + "operation": "assertIsNotNone" + }, + { + "expression": "self.assertEqual(result[\"core\"][\"targets\"][0][\"unresolved_fields\"], [\"type_content_bytes\", \"type_content_sha256\"])", + "line": 376, + "operation": "assertEqual" + }, + { + "expression": "self.assert_collection_baseline(result)", + "line": 378, + "operation": "assert_collection_baseline" + }, + { + "expression": "self.assertEqual([target[\"target\"] for target in result[\"core\"][\"targets\"]], [\"Demo.t\", \"Demo.unlinked\"])", + "line": 379, + "operation": "assertEqual" + }, + { + "expression": "self.assertEqual(result[\"core\"][\"targets\"][1][\"accepted_formal_statement_selector\"], [])", + "line": 382, + "operation": "assertEqual" + }, + { + "expression": "self.assertEqual(result[\"core\"][\"targets\"][1][\"accepted_formal_proof_selector\"], [])", + "line": 383, + "operation": "assertEqual" + }, + { + "expression": "self.assertEqual(target[\"unresolved_fields\"], [\"type_content_bytes\", \"type_content_sha256\"])", + "line": 381, + "operation": "assertEqual" + } + ], + "break_caught": "Unknown type promoted to formal digest or no diagnostic despite complete synthetic enumeration", + "category": "null_diagnostic", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified", + "R01 exact closed full-ref/raw/native/role fixture prerequisites checked before mutation; product exact diagnostic baseline held before isolated collection refusal" + ], + "id": "test_formal_regression.ContractControls.test_unknown_required_type_is_diagnostic", + "normal_and_optimized": true, + "proposed_boundary_decision": true, + "r01_additive_subtests": "Additional assertions/subtests inside this unchanged explicit method ID; full source is normative." + }, + { + "actual_result": "NOT_EXECUTED", + "assertions": [], + "break_caught": "Unknown/unsorted/duplicated unresolved field names accepted", + "category": "unresolved_names", + "contract_basis": "DATA lexical_rules / formal_inventory_hash_contract", + "expected_qualified_implementation": "PASS", + "expected_scaffold": "ASSERTION_FAILURE", + "expected_scaffold_failure_kind": "unittest assertion failure; errors/import/setup/skip failures mean HOLD", + "held_positive_and_unrelated_predicates": [ + "exact fixture source pins/preimage consistency", + "complete imports/setup and exact discovery in this mode", + "all nonmutated fields retain accepted/proposed synthetic profile values", + "valid baseline/request/policy positives must pass before GREEN refusal credit", + "native/mapping/runtime/custody authority remains unqualified" + ], + "helper_assertions": [ + "reject_core: assertRaises(ValueError) around inventory_sha256 mutation" + ], + "id": "test_formal_regression.ContractControls.test_unresolved_names_are_exact_sorted_unique", + "normal_and_optimized": true, + "proposed_boundary_decision": false + } + ], + "minimal_core_preimage": { + "bytes": 977, + "path": "architecture/formal_regression.py", + "role": "HISTORICAL_RED_SCAFFOLD_ONLY; excluded from frozen_sources so future qualified GREEN may implement core", + "sha256": "64dadd7d0c9a365a3f2f707a2b485c9ac4674d1c1b75a95b09d420c2cdd9a872" + }, + "mode_inventory": { + "normal": { + "actual": "NOT_EXECUTED", + "count": 116, + "ids": [ + "test_formal_regression.ContractControls.test_all_thirteen_target_fields_are_required", + "test_formal_regression.ContractControls.test_canonical_vector_0", + "test_formal_regression.ContractControls.test_canonical_vector_1", + "test_formal_regression.ContractControls.test_canonical_vector_2", + "test_formal_regression.ContractControls.test_canonical_vector_3", + "test_formal_regression.ContractControls.test_canonical_vector_4", + "test_formal_regression.ContractControls.test_canonical_vector_5", + "test_formal_regression.ContractControls.test_canonical_vector_6", + "test_formal_regression.ContractControls.test_canonical_vector_7", + "test_formal_regression.ContractControls.test_canonical_vector_8", + "test_formal_regression.ContractControls.test_collection_nonimage_null_does_not_admit_image_runtime", + "test_formal_regression.ContractControls.test_collection_refuses_ambiguous_enumeration", + "test_formal_regression.ContractControls.test_collection_refuses_duplicate_native_record", + "test_formal_regression.ContractControls.test_collection_refuses_foreign_native_target", + "test_formal_regression.ContractControls.test_collection_refuses_foreign_selector_link", + "test_formal_regression.ContractControls.test_collection_refuses_missing_enumeration", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_build_role", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_dependency", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_import_role", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_native_target", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_producer_role", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_scope_role", + "test_formal_regression.ContractControls.test_collection_refuses_origin_relabelled_snapshot", + "test_formal_regression.ContractControls.test_collection_refuses_raw_source_digest_mismatch", + "test_formal_regression.ContractControls.test_collection_refuses_selector_raw_slice_mismatch", + "test_formal_regression.ContractControls.test_collection_refuses_snapshot_source_wrong_commit", + "test_formal_regression.ContractControls.test_collection_refuses_unknown_enumeration", + "test_formal_regression.ContractControls.test_collection_refuses_unknown_selector_acceptance", + "test_formal_regression.ContractControls.test_collection_refuses_unsupported_native_format", + "test_formal_regression.ContractControls.test_collection_unknown_enumeration_has_no_core", + "test_formal_regression.ContractControls.test_collection_zero_links_is_known_absence_diagnostic", + "test_formal_regression.ContractControls.test_compiler_binary_and_version_content_closed", + "test_formal_regression.ContractControls.test_compiler_dependency_content_closed", + "test_formal_regression.ContractControls.test_conflicting_duplicate_target_identity_refuses", + "test_formal_regression.ContractControls.test_dependency_and_runtime_arrays_require_canonical_order", + "test_formal_regression.ContractControls.test_dependency_names_unique_and_revisions_full", + "test_formal_regression.ContractControls.test_duplicate_identity_refuses", + "test_formal_regression.ContractControls.test_duplicate_source_role_paths_refuse", + "test_formal_regression.ContractControls.test_exact_integer_excludes_boolean", + "test_formal_regression.ContractControls.test_fixture_preimages_are_independent", + "test_formal_regression.ContractControls.test_import_set_excludes_target_module", + "test_formal_regression.ContractControls.test_inventory_baseline_hash", + "test_formal_regression.ContractControls.test_inventory_root_is_closed", + "test_formal_regression.ContractControls.test_inventory_root_types_and_domain", + "test_formal_regression.ContractControls.test_native_format_is_supported", + "test_formal_regression.ContractControls.test_native_identity_cannot_be_unresolved", + "test_formal_regression.ContractControls.test_negative_or_fractional_sizes_refuse", + "test_formal_regression.ContractControls.test_nested_compiler_runtime_and_selector_extra_fields_refuse", + "test_formal_regression.ContractControls.test_null_and_empty_selectors_are_distinct", + "test_formal_regression.ContractControls.test_options_remain_ordered_strings", + "test_formal_regression.ContractControls.test_origin_commit_remains_in_content_digest", + "test_formal_regression.ContractControls.test_origin_requires_all_six_full_ref_fields", + "test_formal_regression.ContractControls.test_package_identity_closed_and_safe", + "test_formal_regression.ContractControls.test_policy_boolean_version_refuses", + "test_formal_regression.ContractControls.test_policy_closed_field_set", + "test_formal_regression.ContractControls.test_policy_decode_uses_exact_raw_pin", + "test_formal_regression.ContractControls.test_policy_refuses_depth", + "test_formal_regression.ContractControls.test_policy_refuses_duplicate", + "test_formal_regression.ContractControls.test_policy_refuses_extra_field", + "test_formal_regression.ContractControls.test_policy_refuses_nonfinite", + "test_formal_regression.ContractControls.test_policy_refuses_oversize", + "test_formal_regression.ContractControls.test_policy_refuses_trailing", + "test_formal_regression.ContractControls.test_policy_whitespace_is_part_of_raw_pin", + "test_formal_regression.ContractControls.test_policy_wrong_raw_pin_refuses", + "test_formal_regression.ContractControls.test_print_options_order_changes_digest", + "test_formal_regression.ContractControls.test_recollection_keeps_content_digest", + "test_formal_regression.ContractControls.test_repeated_source_roles_cannot_disagree", + "test_formal_regression.ContractControls.test_request_commit_and_tree_are_full_lowercase_hashes", + "test_formal_regression.ContractControls.test_request_commit_refs_are_closed", + "test_formal_regression.ContractControls.test_request_decode_roundtrip", + "test_formal_regression.ContractControls.test_request_key_changes_each_source_identity", + "test_formal_regression.ContractControls.test_request_key_exact_domain_formula", + "test_formal_regression.ContractControls.test_request_key_refuses_acquisition_fields", + "test_formal_regression.ContractControls.test_request_refuses_bom", + "test_formal_regression.ContractControls.test_request_refuses_boolean_native_id", + "test_formal_regression.ContractControls.test_request_refuses_boolean_version", + "test_formal_regression.ContractControls.test_request_refuses_depth_over_64", + "test_formal_regression.ContractControls.test_request_refuses_duplicate_nested_key", + "test_formal_regression.ContractControls.test_request_refuses_duplicate_top_key", + "test_formal_regression.ContractControls.test_request_refuses_head_fallback", + "test_formal_regression.ContractControls.test_request_refuses_integer_native_id", + "test_formal_regression.ContractControls.test_request_refuses_invalid_utf8", + "test_formal_regression.ContractControls.test_request_refuses_missing_and_extra_fields", + "test_formal_regression.ContractControls.test_request_refuses_noncanonical_native_id", + "test_formal_regression.ContractControls.test_request_refuses_nonfinite_infinity", + "test_formal_regression.ContractControls.test_request_refuses_nonfinite_nan", + "test_formal_regression.ContractControls.test_request_refuses_nonfinite_negative_infinity", + "test_formal_regression.ContractControls.test_request_refuses_oversize", + "test_formal_regression.ContractControls.test_request_refuses_raw_bytearray", + "test_formal_regression.ContractControls.test_request_refuses_raw_str", + "test_formal_regression.ContractControls.test_request_refuses_supplied_url", + "test_formal_regression.ContractControls.test_request_refuses_trailing_value", + "test_formal_regression.ContractControls.test_request_refuses_uppercase_digest", + "test_formal_regression.ContractControls.test_request_refuses_wrong_merge_parents", + "test_formal_regression.ContractControls.test_request_refuses_wrong_root_type", + "test_formal_regression.ContractControls.test_required_null_needs_exact_unresolved_name", + "test_formal_regression.ContractControls.test_required_type_null_pair_cannot_be_half_known", + "test_formal_regression.ContractControls.test_runtime_executable_is_complete_nonempty_named_content", + "test_formal_regression.ContractControls.test_runtime_executable_names_unique", + "test_formal_regression.ContractControls.test_runtime_identity_closed", + "test_formal_regression.ContractControls.test_scope_and_import_role_values_are_arrays", + "test_formal_regression.ContractControls.test_scope_and_import_sets_closed", + "test_formal_regression.ContractControls.test_selector_bounds_are_exact", + "test_formal_regression.ContractControls.test_selector_entry_and_slice_closed", + "test_formal_regression.ContractControls.test_selector_link_sets_complete_and_unique", + "test_formal_regression.ContractControls.test_semantic_options_order_changes_digest", + "test_formal_regression.ContractControls.test_seven_content_deltas", + "test_formal_regression.ContractControls.test_snapshot_source_has_exact_six_content_fields", + "test_formal_regression.ContractControls.test_source_hashes_are_canonical", + "test_formal_regression.ContractControls.test_source_paths_refuse_escape_absolute_and_url", + "test_formal_regression.ContractControls.test_source_role_arrays_require_canonical_order", + "test_formal_regression.ContractControls.test_source_role_lists_have_unique_canonical_identity", + "test_formal_regression.ContractControls.test_target_array_requires_canonical_identity_order", + "test_formal_regression.ContractControls.test_target_unknown_field_refuses", + "test_formal_regression.ContractControls.test_unknown_required_type_is_diagnostic", + "test_formal_regression.ContractControls.test_unresolved_names_are_exact_sorted_unique" + ], + "must_have_errors": 0, + "must_have_skips": 0 + }, + "optimized": { + "actual": "NOT_EXECUTED", + "count": 116, + "ids": [ + "test_formal_regression.ContractControls.test_all_thirteen_target_fields_are_required", + "test_formal_regression.ContractControls.test_canonical_vector_0", + "test_formal_regression.ContractControls.test_canonical_vector_1", + "test_formal_regression.ContractControls.test_canonical_vector_2", + "test_formal_regression.ContractControls.test_canonical_vector_3", + "test_formal_regression.ContractControls.test_canonical_vector_4", + "test_formal_regression.ContractControls.test_canonical_vector_5", + "test_formal_regression.ContractControls.test_canonical_vector_6", + "test_formal_regression.ContractControls.test_canonical_vector_7", + "test_formal_regression.ContractControls.test_canonical_vector_8", + "test_formal_regression.ContractControls.test_collection_nonimage_null_does_not_admit_image_runtime", + "test_formal_regression.ContractControls.test_collection_refuses_ambiguous_enumeration", + "test_formal_regression.ContractControls.test_collection_refuses_duplicate_native_record", + "test_formal_regression.ContractControls.test_collection_refuses_foreign_native_target", + "test_formal_regression.ContractControls.test_collection_refuses_foreign_selector_link", + "test_formal_regression.ContractControls.test_collection_refuses_missing_enumeration", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_build_role", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_dependency", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_import_role", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_native_target", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_producer_role", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_scope_role", + "test_formal_regression.ContractControls.test_collection_refuses_origin_relabelled_snapshot", + "test_formal_regression.ContractControls.test_collection_refuses_raw_source_digest_mismatch", + "test_formal_regression.ContractControls.test_collection_refuses_selector_raw_slice_mismatch", + "test_formal_regression.ContractControls.test_collection_refuses_snapshot_source_wrong_commit", + "test_formal_regression.ContractControls.test_collection_refuses_unknown_enumeration", + "test_formal_regression.ContractControls.test_collection_refuses_unknown_selector_acceptance", + "test_formal_regression.ContractControls.test_collection_refuses_unsupported_native_format", + "test_formal_regression.ContractControls.test_collection_unknown_enumeration_has_no_core", + "test_formal_regression.ContractControls.test_collection_zero_links_is_known_absence_diagnostic", + "test_formal_regression.ContractControls.test_compiler_binary_and_version_content_closed", + "test_formal_regression.ContractControls.test_compiler_dependency_content_closed", + "test_formal_regression.ContractControls.test_conflicting_duplicate_target_identity_refuses", + "test_formal_regression.ContractControls.test_dependency_and_runtime_arrays_require_canonical_order", + "test_formal_regression.ContractControls.test_dependency_names_unique_and_revisions_full", + "test_formal_regression.ContractControls.test_duplicate_identity_refuses", + "test_formal_regression.ContractControls.test_duplicate_source_role_paths_refuse", + "test_formal_regression.ContractControls.test_exact_integer_excludes_boolean", + "test_formal_regression.ContractControls.test_fixture_preimages_are_independent", + "test_formal_regression.ContractControls.test_import_set_excludes_target_module", + "test_formal_regression.ContractControls.test_inventory_baseline_hash", + "test_formal_regression.ContractControls.test_inventory_root_is_closed", + "test_formal_regression.ContractControls.test_inventory_root_types_and_domain", + "test_formal_regression.ContractControls.test_native_format_is_supported", + "test_formal_regression.ContractControls.test_native_identity_cannot_be_unresolved", + "test_formal_regression.ContractControls.test_negative_or_fractional_sizes_refuse", + "test_formal_regression.ContractControls.test_nested_compiler_runtime_and_selector_extra_fields_refuse", + "test_formal_regression.ContractControls.test_null_and_empty_selectors_are_distinct", + "test_formal_regression.ContractControls.test_options_remain_ordered_strings", + "test_formal_regression.ContractControls.test_origin_commit_remains_in_content_digest", + "test_formal_regression.ContractControls.test_origin_requires_all_six_full_ref_fields", + "test_formal_regression.ContractControls.test_package_identity_closed_and_safe", + "test_formal_regression.ContractControls.test_policy_boolean_version_refuses", + "test_formal_regression.ContractControls.test_policy_closed_field_set", + "test_formal_regression.ContractControls.test_policy_decode_uses_exact_raw_pin", + "test_formal_regression.ContractControls.test_policy_refuses_depth", + "test_formal_regression.ContractControls.test_policy_refuses_duplicate", + "test_formal_regression.ContractControls.test_policy_refuses_extra_field", + "test_formal_regression.ContractControls.test_policy_refuses_nonfinite", + "test_formal_regression.ContractControls.test_policy_refuses_oversize", + "test_formal_regression.ContractControls.test_policy_refuses_trailing", + "test_formal_regression.ContractControls.test_policy_whitespace_is_part_of_raw_pin", + "test_formal_regression.ContractControls.test_policy_wrong_raw_pin_refuses", + "test_formal_regression.ContractControls.test_print_options_order_changes_digest", + "test_formal_regression.ContractControls.test_recollection_keeps_content_digest", + "test_formal_regression.ContractControls.test_repeated_source_roles_cannot_disagree", + "test_formal_regression.ContractControls.test_request_commit_and_tree_are_full_lowercase_hashes", + "test_formal_regression.ContractControls.test_request_commit_refs_are_closed", + "test_formal_regression.ContractControls.test_request_decode_roundtrip", + "test_formal_regression.ContractControls.test_request_key_changes_each_source_identity", + "test_formal_regression.ContractControls.test_request_key_exact_domain_formula", + "test_formal_regression.ContractControls.test_request_key_refuses_acquisition_fields", + "test_formal_regression.ContractControls.test_request_refuses_bom", + "test_formal_regression.ContractControls.test_request_refuses_boolean_native_id", + "test_formal_regression.ContractControls.test_request_refuses_boolean_version", + "test_formal_regression.ContractControls.test_request_refuses_depth_over_64", + "test_formal_regression.ContractControls.test_request_refuses_duplicate_nested_key", + "test_formal_regression.ContractControls.test_request_refuses_duplicate_top_key", + "test_formal_regression.ContractControls.test_request_refuses_head_fallback", + "test_formal_regression.ContractControls.test_request_refuses_integer_native_id", + "test_formal_regression.ContractControls.test_request_refuses_invalid_utf8", + "test_formal_regression.ContractControls.test_request_refuses_missing_and_extra_fields", + "test_formal_regression.ContractControls.test_request_refuses_noncanonical_native_id", + "test_formal_regression.ContractControls.test_request_refuses_nonfinite_infinity", + "test_formal_regression.ContractControls.test_request_refuses_nonfinite_nan", + "test_formal_regression.ContractControls.test_request_refuses_nonfinite_negative_infinity", + "test_formal_regression.ContractControls.test_request_refuses_oversize", + "test_formal_regression.ContractControls.test_request_refuses_raw_bytearray", + "test_formal_regression.ContractControls.test_request_refuses_raw_str", + "test_formal_regression.ContractControls.test_request_refuses_supplied_url", + "test_formal_regression.ContractControls.test_request_refuses_trailing_value", + "test_formal_regression.ContractControls.test_request_refuses_uppercase_digest", + "test_formal_regression.ContractControls.test_request_refuses_wrong_merge_parents", + "test_formal_regression.ContractControls.test_request_refuses_wrong_root_type", + "test_formal_regression.ContractControls.test_required_null_needs_exact_unresolved_name", + "test_formal_regression.ContractControls.test_required_type_null_pair_cannot_be_half_known", + "test_formal_regression.ContractControls.test_runtime_executable_is_complete_nonempty_named_content", + "test_formal_regression.ContractControls.test_runtime_executable_names_unique", + "test_formal_regression.ContractControls.test_runtime_identity_closed", + "test_formal_regression.ContractControls.test_scope_and_import_role_values_are_arrays", + "test_formal_regression.ContractControls.test_scope_and_import_sets_closed", + "test_formal_regression.ContractControls.test_selector_bounds_are_exact", + "test_formal_regression.ContractControls.test_selector_entry_and_slice_closed", + "test_formal_regression.ContractControls.test_selector_link_sets_complete_and_unique", + "test_formal_regression.ContractControls.test_semantic_options_order_changes_digest", + "test_formal_regression.ContractControls.test_seven_content_deltas", + "test_formal_regression.ContractControls.test_snapshot_source_has_exact_six_content_fields", + "test_formal_regression.ContractControls.test_source_hashes_are_canonical", + "test_formal_regression.ContractControls.test_source_paths_refuse_escape_absolute_and_url", + "test_formal_regression.ContractControls.test_source_role_arrays_require_canonical_order", + "test_formal_regression.ContractControls.test_source_role_lists_have_unique_canonical_identity", + "test_formal_regression.ContractControls.test_target_array_requires_canonical_identity_order", + "test_formal_regression.ContractControls.test_target_unknown_field_refuses", + "test_formal_regression.ContractControls.test_unknown_required_type_is_diagnostic", + "test_formal_regression.ContractControls.test_unresolved_names_are_exact_sorted_unique" + ], + "must_have_errors": 0, + "must_have_skips": 0 + } + }, + "organization_independence": 0, + "qualified_GREEN": false, + "qualified_RED": false, + "remaining_Task1_requirements": [ + "distinct whole controls/core/scaffold/caller review and resolution of explicit internal shape decisions", + "dedicated hosted caller preparation/resource/stream/native-original qualification", + "genuine both-mode per-method assertion RED on this exact scaffold, zero errors/skips", + "working core only after qualifying RED, unchanged frozen sources/control-plan and both-mode GREEN", + "additional enforcement test file plus required CLI/API/source-conservation refusal controls under separate finite scope", + "distinct actual source/runtime/original custody/cleanup evidence qualification; no full Task1 completion is claimed" + ], + "request_key_oracle": { + "canonical_ascii_preimage": "{\"context\":{\"base\":{\"commit\":\"1111111111111111111111111111111111111111\",\"repository\":\"fixture/collector-contract\",\"tree\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"},\"base_ref\":\"main\",\"checked_merge\":{\"commit\":\"3333333333333333333333333333333333333333\",\"repository\":\"fixture/collector-contract\",\"tree\":\"cccccccccccccccccccccccccccccccccccccccc\"},\"checked_merge_parents\":[\"1111111111111111111111111111111111111111\",\"2222222222222222222222222222222222222222\"],\"control\":{\"commit\":\"4444444444444444444444444444444444444444\",\"repository\":\"fixture/control\",\"tree\":\"dddddddddddddddddddddddddddddddddddddddd\"},\"head\":{\"commit\":\"2222222222222222222222222222222222222222\",\"repository\":\"fixture/collector-contract\",\"tree\":\"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"},\"head_ref\":\"fixture-head\",\"merge_mode\":\"service_merge\",\"policy_sha256\":\"f6f115506e2b0b7600dbd68cd394b5e0d6de56f8fa105eac87a9fda5de2f4e58\",\"pull_request\":\"17\",\"repository\":\"fixture/collector-contract\",\"schema_version\":1},\"domain\":\"formal-regression-request/v1\"}", + "derivation": "Own inert stdlib literal derivation; concrete R01 policy raw pin and control repository are consistent, no product code", + "formula": "SHA256(CanonicalASCII({domain:formal-regression-request/v1,context:request}))", + "sha256": "ac1cffe262a84ab7fb9ee3eece0d93b2a3e0b89b00a7ff1c9d747b9aa5abbd8d" + }, + "runtime_status": "NOT_EXECUTED", + "schema_version": 1, + "scientific_effect": "NONE", + "scope_limits": [ + "First-core controls/scaffold only; not complete Task1", + "Both enforcement test and remaining transport/runtime/security/semantic classes are mandatory later", + "All M1-M7 remain unqualified", + "No CLI/API/runtime/custody/publisher/protected-source admission is established", + "Future source publication must refresh actual Main/current owners/whole diff and preserve unrelated leaves" + ], + "synthetic_test_boundary_profile": { + "acceptances": { + "domain_id": "fixture-only-domain", + "links": [ + { + "formal_proof_selector": { + "end_byte": 55, + "sha256": "f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98", + "source": { + "bytes": 56, + "git_blob": "1e604667139c6d43c69c0af76160c2374b5ef65c", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d" + }, + "start_byte": 45 + }, + "formal_statement_selector": { + "end_byte": 41, + "sha256": "1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7", + "source": { + "bytes": 56, + "git_blob": "1e604667139c6d43c69c0af76160c2374b5ef65c", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d" + }, + "start_byte": 20 + }, + "link_id": "fixture-link", + "target": "Demo.t" + }, + { + "formal_proof_selector": { + "end_byte": 55, + "sha256": "f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98", + "source": { + "bytes": 56, + "git_blob": "1e604667139c6d43c69c0af76160c2374b5ef65c", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d" + }, + "start_byte": 45 + }, + "formal_statement_selector": { + "end_byte": 41, + "sha256": "1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7", + "source": { + "bytes": 56, + "git_blob": "1e604667139c6d43c69c0af76160c2374b5ef65c", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d" + }, + "start_byte": 20 + }, + "link_id": "z-fixture-link", + "target": "Demo.t" + } + ], + "qualification": "SYNTHETIC_ONLY_NOT_NATIVE_ACCEPTANCE", + "schema_version": 1 + }, + "authority": "NONE; no native source/execution/mapping/review/production acceptance or science is supplied by fixtures, digests, labels or booleans.", + "diagnostic_policy": { + "disclosure": null, + "enforcement": null, + "gate_sha256": "a78f3e25f3b0cfe113e618a4c31a7a25d7f22af638c46dec1ecba221fa333ac8", + "graph_sources": [], + "limits": { + "json_bytes": 16777216, + "json_depth": 64 + }, + "mapping_authorities": [], + "native_producer_policies": [ + { + "artifact_inventory_contract": { + "mode": "SYNTHETIC_STRUCTURAL_INPUT_ONLY", + "native_originals": "UNQUALIFIED" + }, + "attempt_custody_contract": { + "mode": "UNQUALIFIED", + "native_context": null + }, + "dependency_policy": { + "lock_ref": { + "bytes": 672, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "1dfc2ed4c155de7c1ca5dc2ca4171dccea3b1c5d", + "path": "formal/lake-manifest.json", + "repository": "fixture/collector-contract", + "sha256": "5ade86188a7c4f0ca0f4254318100cc7930d514375c4a256551c9254b84b2658" + }, + "revisions": [ + { + "name": "a_fixture", + "revision": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + }, + { + "name": "z_fixture", + "revision": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" + } + ] + }, + "format": "main-formal-gate/v1", + "print_options": [ + "pp.explicit=true", + "pp.universes=true" + ], + "runtime_identity": { + "executables": [ + { + "content": { + "bytes": 32, + "sha256": "f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00" + }, + "name": "lean" + }, + { + "content": { + "bytes": 38, + "sha256": "b1a11ede32499568db933c8703d668015ef50342193338fd2e9fec59913e9be0" + }, + "name": "python" + } + ], + "image_manifest": null, + "platform": "synthetic-linux-amd64-nonimage" + }, + "sandbox_contract": { + "authority": "NONE", + "mode": "NOT_RUN" + }, + "source_control_files": { + "build_config": [ + { + "bytes": 85, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "c31b8ba6189dc0872704f4ea910f468502b3934d", + "path": "formal/Fixture.lean", + "repository": "fixture/collector-contract", + "sha256": "24766498266ca3327ab43ce2551807099a474324ad4d1c9f5f2e0052c4e11afa" + }, + { + "bytes": 65, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "225d58dbcbb1116179103c8637c26e25310687f8", + "path": "formal/lakefile.toml", + "repository": "fixture/collector-contract", + "sha256": "66f41c071ca37d39d785a00d298ee2fb4f851b9d5a749d33928f97cbf405970b" + }, + { + "bytes": 25, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5", + "path": "formal/lean-toolchain", + "repository": "fixture/collector-contract", + "sha256": "d5edba4e4b8faad9c1baeadb265716d20d03be4d1a2647dc5e35b0c0325bea7b" + } + ], + "import_files": [ + { + "bytes": 59, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "02e8e595beb0686b7cbc722923d2dd679552b2a0", + "path": "formal/Fixture/Base.lean", + "repository": "fixture/collector-contract", + "sha256": "dc90d249b1695b7048e28233959e8aa5511f9f93dc1984be5a0be0989ec99683" + }, + { + "bytes": 28, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "ec04f5b06cd1556280b6214bf6247dff75ab1a6f", + "path": "formal/Fixture/Extra.lean", + "repository": "fixture/collector-contract", + "sha256": "c8fe60595798b75c502b37d5e92b44a23a37a285a904cbe2552078826af7a1f7" + } + ], + "producer_sources": [ + { + "bytes": 73, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "83fad939382bf3c996a5b707ca3f69f1fc25a02f", + "path": "tools/formal_gate_check.py", + "repository": "fixture/collector-contract", + "sha256": "698870017e3fde8a8c5743a2a6b2e9ff6a2a93cc78f0284546049794141542c4" + }, + { + "bytes": 56, + "commit": "4444444444444444444444444444444444444444", + "git_blob": "cec033cc05bd392aa103ca10838d9db8c5cda786", + "path": "control/supervisor.py", + "repository": "fixture/control", + "sha256": "ae4d3070f92e31d2f8c662eded4226e987630bf7a8e2cf307f5d40016b0106f1" + }, + { + "bytes": 73, + "commit": "4444444444444444444444444444444444444444", + "git_blob": "8eed3c0a0318245082c027b7a006cf5d853f5ddc", + "path": "control/native-workflow.yml", + "repository": "fixture/control", + "sha256": "a768034663901091e4bd85420c43fd98ffabce3ce1f9ed17327a918e11fa45dd" + } + ], + "scope_files": [ + { + "bytes": 92, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "cda22816532dfb264a8739cffc16b6d41cbbbf5e", + "path": "formal/SCOPE.md", + "repository": "fixture/collector-contract", + "sha256": "765aa85be38b913b07548a56f21c600749ea727a96cbeb99d345ea30f317731b" + }, + { + "bytes": 73, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "97d8569986750f071d006023b656b2651b263c73", + "path": "formal/GLOSSARY.md", + "repository": "fixture/collector-contract", + "sha256": "554783837178438d8c9cac728e8be4ba8edabadfc64e736227ae9e0e8f9293bd" + } + ], + "target_inputs": [ + { + "imports": [ + { + "bytes": 59, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "02e8e595beb0686b7cbc722923d2dd679552b2a0", + "path": "formal/Fixture/Base.lean", + "repository": "fixture/collector-contract", + "sha256": "dc90d249b1695b7048e28233959e8aa5511f9f93dc1984be5a0be0989ec99683" + }, + { + "bytes": 28, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "ec04f5b06cd1556280b6214bf6247dff75ab1a6f", + "path": "formal/Fixture/Extra.lean", + "repository": "fixture/collector-contract", + "sha256": "c8fe60595798b75c502b37d5e92b44a23a37a285a904cbe2552078826af7a1f7" + } + ], + "target": "Demo.t" + }, + { + "imports": [ + { + "bytes": 59, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "02e8e595beb0686b7cbc722923d2dd679552b2a0", + "path": "formal/Fixture/Base.lean", + "repository": "fixture/collector-contract", + "sha256": "dc90d249b1695b7048e28233959e8aa5511f9f93dc1984be5a0be0989ec99683" + }, + { + "bytes": 28, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "ec04f5b06cd1556280b6214bf6247dff75ab1a6f", + "path": "formal/Fixture/Extra.lean", + "repository": "fixture/collector-contract", + "sha256": "c8fe60595798b75c502b37d5e92b44a23a37a285a904cbe2552078826af7a1f7" + } + ], + "target": "Demo.unlinked" + } + ] + }, + "supervisor_source_refs": [ + { + "bytes": 56, + "commit": "4444444444444444444444444444444444444444", + "git_blob": "cec033cc05bd392aa103ca10838d9db8c5cda786", + "path": "control/supervisor.py", + "repository": "fixture/control", + "sha256": "ae4d3070f92e31d2f8c662eded4226e987630bf7a8e2cf307f5d40016b0106f1" + }, + { + "bytes": 73, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "83fad939382bf3c996a5b707ca3f69f1fc25a02f", + "path": "tools/formal_gate_check.py", + "repository": "fixture/collector-contract", + "sha256": "698870017e3fde8a8c5743a2a6b2e9ff6a2a93cc78f0284546049794141542c4" + } + ], + "toolchain": "leanprover/lean4:v4.34.1", + "workflow_source_ref": { + "bytes": 73, + "commit": "4444444444444444444444444444444444444444", + "git_blob": "8eed3c0a0318245082c027b7a006cf5d853f5ddc", + "path": "control/native-workflow.yml", + "repository": "fixture/control", + "sha256": "a768034663901091e4bd85420c43fd98ffabce3ce1f9ed17327a918e11fa45dd" + } + } + ], + "preservation": null, + "protected_domains": [ + "fixture-only-domain" + ], + "publisher": null, + "repositories": [ + "fixture/collector-contract", + "fixture/control", + "fixture/informal", + "fixture/runtime" + ], + "review_authorities": [], + "schema_version": 1, + "trusted_control_sources": [ + { + "bytes": 73, + "commit": "4444444444444444444444444444444444444444", + "git_blob": "8eed3c0a0318245082c027b7a006cf5d853f5ddc", + "path": "control/native-workflow.yml", + "repository": "fixture/control", + "sha256": "a768034663901091e4bd85420c43fd98ffabce3ce1f9ed17327a918e11fa45dd" + }, + { + "bytes": 56, + "commit": "4444444444444444444444444444444444444444", + "git_blob": "cec033cc05bd392aa103ca10838d9db8c5cda786", + "path": "control/supervisor.py", + "repository": "fixture/control", + "sha256": "ae4d3070f92e31d2f8c662eded4226e987630bf7a8e2cf307f5d40016b0106f1" + } + ] + }, + "expected_diagnostic_ascii_preimage": "{\"domain\":\"formal-regression-inventory/v1\",\"domain_id\":\"fixture-only-domain\",\"targets\":[{\"accepted_formal_proof_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":55,\"sha256\":\"f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98\",\"source\":{\"bytes\":56,\"git_blob\":\"1e604667139c6d43c69c0af76160c2374b5ef65c\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d\"},\"start_byte\":45}},{\"link_id\":\"z-fixture-link\",\"selector\":{\"end_byte\":55,\"sha256\":\"f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98\",\"source\":{\"bytes\":56,\"git_blob\":\"1e604667139c6d43c69c0af76160c2374b5ef65c\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d\"},\"start_byte\":45}}],\"accepted_formal_statement_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":41,\"sha256\":\"1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7\",\"source\":{\"bytes\":56,\"git_blob\":\"1e604667139c6d43c69c0af76160c2374b5ef65c\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d\"},\"start_byte\":20}},{\"link_id\":\"z-fixture-link\",\"selector\":{\"end_byte\":41,\"sha256\":\"1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7\",\"source\":{\"bytes\":56,\"git_blob\":\"1e604667139c6d43c69c0af76160c2374b5ef65c\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d\"},\"start_byte\":20}}],\"compiler_dependency_options_identity\":{\"build_config\":[{\"bytes\":85,\"git_blob\":\"c31b8ba6189dc0872704f4ea910f468502b3934d\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"24766498266ca3327ab43ce2551807099a474324ad4d1c9f5f2e0052c4e11afa\"},{\"bytes\":65,\"git_blob\":\"225d58dbcbb1116179103c8637c26e25310687f8\",\"kind\":\"snapshot\",\"path\":\"formal/lakefile.toml\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"66f41c071ca37d39d785a00d298ee2fb4f851b9d5a749d33928f97cbf405970b\"},{\"bytes\":25,\"git_blob\":\"ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5\",\"kind\":\"snapshot\",\"path\":\"formal/lean-toolchain\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"d5edba4e4b8faad9c1baeadb265716d20d03be4d1a2647dc5e35b0c0325bea7b\"}],\"compiler_identity\":{\"executable\":{\"bytes\":32,\"sha256\":\"f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00\"},\"version_output\":{\"bytes\":46,\"sha256\":\"09ae09205b0965c3841e1e334f268c5a6f7baf45eddad66cd0398d6fd9850e55\"}},\"dependencies\":[{\"name\":\"a_fixture\",\"revision\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"},{\"name\":\"z_fixture\",\"revision\":\"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"}],\"dependency_lock\":{\"bytes\":672,\"git_blob\":\"1dfc2ed4c155de7c1ca5dc2ca4171dccea3b1c5d\",\"kind\":\"snapshot\",\"path\":\"formal/lake-manifest.json\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"5ade86188a7c4f0ca0f4254318100cc7930d514375c4a256551c9254b84b2658\"},\"options\":[\"autoImplicit=false\",\"maxRecDepth=128\"],\"print_options\":[\"pp.explicit=true\",\"pp.universes=true\"],\"producer_sources\":[{\"bytes\":73,\"git_blob\":\"83fad939382bf3c996a5b707ca3f69f1fc25a02f\",\"kind\":\"snapshot\",\"path\":\"tools/formal_gate_check.py\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"698870017e3fde8a8c5743a2a6b2e9ff6a2a93cc78f0284546049794141542c4\"},{\"kind\":\"origin\",\"ref\":{\"bytes\":73,\"commit\":\"4444444444444444444444444444444444444444\",\"git_blob\":\"8eed3c0a0318245082c027b7a006cf5d853f5ddc\",\"path\":\"control/native-workflow.yml\",\"repository\":\"fixture/control\",\"sha256\":\"a768034663901091e4bd85420c43fd98ffabce3ce1f9ed17327a918e11fa45dd\"}},{\"kind\":\"origin\",\"ref\":{\"bytes\":56,\"commit\":\"4444444444444444444444444444444444444444\",\"git_blob\":\"cec033cc05bd392aa103ca10838d9db8c5cda786\",\"path\":\"control/supervisor.py\",\"repository\":\"fixture/control\",\"sha256\":\"ae4d3070f92e31d2f8c662eded4226e987630bf7a8e2cf307f5d40016b0106f1\"}}],\"runtime_identity\":{\"executables\":[{\"content\":{\"bytes\":32,\"sha256\":\"f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00\"},\"name\":\"lean\"},{\"content\":{\"bytes\":38,\"sha256\":\"b1a11ede32499568db933c8703d668015ef50342193338fd2e9fec59913e9be0\"},\"name\":\"python\"}],\"image_manifest\":null,\"platform\":\"synthetic-linux-amd64-nonimage\"},\"toolchain\":\"leanprover/lean4:v4.34.1\"},\"format\":\"main-formal-gate/v1\",\"manifest_contract_sha256\":\"ff592c9cbfc46b0376bb4ca7a33608e858ec9112352dad416bc4b793a1a583d9\",\"module_content_identity\":{\"bytes\":56,\"git_blob\":\"1e604667139c6d43c69c0af76160c2374b5ef65c\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d\"},\"native_repository\":\"fixture/collector-contract\",\"package\":{\"declared_name\":\"Fixture\",\"manifest_path\":\"formal/manifest.json\"},\"scope_content_identity\":{\"import_files\":[{\"bytes\":59,\"git_blob\":\"02e8e595beb0686b7cbc722923d2dd679552b2a0\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Base.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"dc90d249b1695b7048e28233959e8aa5511f9f93dc1984be5a0be0989ec99683\"},{\"bytes\":28,\"git_blob\":\"ec04f5b06cd1556280b6214bf6247dff75ab1a6f\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Extra.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"c8fe60595798b75c502b37d5e92b44a23a37a285a904cbe2552078826af7a1f7\"}],\"scope_files\":[{\"bytes\":73,\"git_blob\":\"97d8569986750f071d006023b656b2651b263c73\",\"kind\":\"snapshot\",\"path\":\"formal/GLOSSARY.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"554783837178438d8c9cac728e8be4ba8edabadfc64e736227ae9e0e8f9293bd\"},{\"bytes\":92,\"git_blob\":\"cda22816532dfb264a8739cffc16b6d41cbbbf5e\",\"kind\":\"snapshot\",\"path\":\"formal/SCOPE.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"765aa85be38b913b07548a56f21c600749ea727a96cbeb99d345ea30f317731b\"}]},\"target\":\"Demo.t\",\"type_content_bytes\":null,\"type_content_sha256\":null,\"unresolved_fields\":[\"type_content_bytes\",\"type_content_sha256\"]},{\"accepted_formal_proof_selector\":[],\"accepted_formal_statement_selector\":[],\"compiler_dependency_options_identity\":{\"build_config\":[{\"bytes\":85,\"git_blob\":\"c31b8ba6189dc0872704f4ea910f468502b3934d\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"24766498266ca3327ab43ce2551807099a474324ad4d1c9f5f2e0052c4e11afa\"},{\"bytes\":65,\"git_blob\":\"225d58dbcbb1116179103c8637c26e25310687f8\",\"kind\":\"snapshot\",\"path\":\"formal/lakefile.toml\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"66f41c071ca37d39d785a00d298ee2fb4f851b9d5a749d33928f97cbf405970b\"},{\"bytes\":25,\"git_blob\":\"ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5\",\"kind\":\"snapshot\",\"path\":\"formal/lean-toolchain\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"d5edba4e4b8faad9c1baeadb265716d20d03be4d1a2647dc5e35b0c0325bea7b\"}],\"compiler_identity\":{\"executable\":{\"bytes\":32,\"sha256\":\"f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00\"},\"version_output\":{\"bytes\":46,\"sha256\":\"09ae09205b0965c3841e1e334f268c5a6f7baf45eddad66cd0398d6fd9850e55\"}},\"dependencies\":[{\"name\":\"a_fixture\",\"revision\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"},{\"name\":\"z_fixture\",\"revision\":\"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"}],\"dependency_lock\":{\"bytes\":672,\"git_blob\":\"1dfc2ed4c155de7c1ca5dc2ca4171dccea3b1c5d\",\"kind\":\"snapshot\",\"path\":\"formal/lake-manifest.json\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"5ade86188a7c4f0ca0f4254318100cc7930d514375c4a256551c9254b84b2658\"},\"options\":[\"autoImplicit=false\",\"maxRecDepth=128\"],\"print_options\":[\"pp.explicit=true\",\"pp.universes=true\"],\"producer_sources\":[{\"bytes\":73,\"git_blob\":\"83fad939382bf3c996a5b707ca3f69f1fc25a02f\",\"kind\":\"snapshot\",\"path\":\"tools/formal_gate_check.py\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"698870017e3fde8a8c5743a2a6b2e9ff6a2a93cc78f0284546049794141542c4\"},{\"kind\":\"origin\",\"ref\":{\"bytes\":73,\"commit\":\"4444444444444444444444444444444444444444\",\"git_blob\":\"8eed3c0a0318245082c027b7a006cf5d853f5ddc\",\"path\":\"control/native-workflow.yml\",\"repository\":\"fixture/control\",\"sha256\":\"a768034663901091e4bd85420c43fd98ffabce3ce1f9ed17327a918e11fa45dd\"}},{\"kind\":\"origin\",\"ref\":{\"bytes\":56,\"commit\":\"4444444444444444444444444444444444444444\",\"git_blob\":\"cec033cc05bd392aa103ca10838d9db8c5cda786\",\"path\":\"control/supervisor.py\",\"repository\":\"fixture/control\",\"sha256\":\"ae4d3070f92e31d2f8c662eded4226e987630bf7a8e2cf307f5d40016b0106f1\"}}],\"runtime_identity\":{\"executables\":[{\"content\":{\"bytes\":32,\"sha256\":\"f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00\"},\"name\":\"lean\"},{\"content\":{\"bytes\":38,\"sha256\":\"b1a11ede32499568db933c8703d668015ef50342193338fd2e9fec59913e9be0\"},\"name\":\"python\"}],\"image_manifest\":null,\"platform\":\"synthetic-linux-amd64-nonimage\"},\"toolchain\":\"leanprover/lean4:v4.34.1\"},\"format\":\"main-formal-gate/v1\",\"manifest_contract_sha256\":\"ff592c9cbfc46b0376bb4ca7a33608e858ec9112352dad416bc4b793a1a583d9\",\"module_content_identity\":{\"bytes\":63,\"git_blob\":\"f1f9e1c25e8e491bd10d931cd6d0a64e78da034f\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Unlinked.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"31015cf8631441e3cb1554075e20247c7e31e8f4c16daabcec21ddc94557142e\"},\"native_repository\":\"fixture/collector-contract\",\"package\":{\"declared_name\":\"Fixture\",\"manifest_path\":\"formal/manifest.json\"},\"scope_content_identity\":{\"import_files\":[{\"bytes\":59,\"git_blob\":\"02e8e595beb0686b7cbc722923d2dd679552b2a0\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Base.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"dc90d249b1695b7048e28233959e8aa5511f9f93dc1984be5a0be0989ec99683\"},{\"bytes\":28,\"git_blob\":\"ec04f5b06cd1556280b6214bf6247dff75ab1a6f\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Extra.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"c8fe60595798b75c502b37d5e92b44a23a37a285a904cbe2552078826af7a1f7\"}],\"scope_files\":[{\"bytes\":73,\"git_blob\":\"97d8569986750f071d006023b656b2651b263c73\",\"kind\":\"snapshot\",\"path\":\"formal/GLOSSARY.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"554783837178438d8c9cac728e8be4ba8edabadfc64e736227ae9e0e8f9293bd\"},{\"bytes\":92,\"git_blob\":\"cda22816532dfb264a8739cffc16b6d41cbbbf5e\",\"kind\":\"snapshot\",\"path\":\"formal/SCOPE.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"765aa85be38b913b07548a56f21c600749ea727a96cbeb99d345ea30f317731b\"}]},\"target\":\"Demo.unlinked\",\"type_content_bytes\":null,\"type_content_sha256\":null,\"unresolved_fields\":[\"type_content_bytes\",\"type_content_sha256\"]}]}", + "expected_diagnostic_core": { + "domain": "formal-regression-inventory/v1", + "domain_id": "fixture-only-domain", + "targets": [ + { + "accepted_formal_proof_selector": [ + { + "link_id": "fixture-link", + "selector": { + "end_byte": 55, + "sha256": "f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98", + "source": { + "bytes": 56, + "git_blob": "1e604667139c6d43c69c0af76160c2374b5ef65c", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d" + }, + "start_byte": 45 + } + }, + { + "link_id": "z-fixture-link", + "selector": { + "end_byte": 55, + "sha256": "f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98", + "source": { + "bytes": 56, + "git_blob": "1e604667139c6d43c69c0af76160c2374b5ef65c", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d" + }, + "start_byte": 45 + } + } + ], + "accepted_formal_statement_selector": [ + { + "link_id": "fixture-link", + "selector": { + "end_byte": 41, + "sha256": "1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7", + "source": { + "bytes": 56, + "git_blob": "1e604667139c6d43c69c0af76160c2374b5ef65c", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d" + }, + "start_byte": 20 + } + }, + { + "link_id": "z-fixture-link", + "selector": { + "end_byte": 41, + "sha256": "1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7", + "source": { + "bytes": 56, + "git_blob": "1e604667139c6d43c69c0af76160c2374b5ef65c", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d" + }, + "start_byte": 20 + } + } + ], + "compiler_dependency_options_identity": { + "build_config": [ + { + "bytes": 85, + "git_blob": "c31b8ba6189dc0872704f4ea910f468502b3934d", + "kind": "snapshot", + "path": "formal/Fixture.lean", + "repository": "fixture/collector-contract", + "sha256": "24766498266ca3327ab43ce2551807099a474324ad4d1c9f5f2e0052c4e11afa" + }, + { + "bytes": 65, + "git_blob": "225d58dbcbb1116179103c8637c26e25310687f8", + "kind": "snapshot", + "path": "formal/lakefile.toml", + "repository": "fixture/collector-contract", + "sha256": "66f41c071ca37d39d785a00d298ee2fb4f851b9d5a749d33928f97cbf405970b" + }, + { + "bytes": 25, + "git_blob": "ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5", + "kind": "snapshot", + "path": "formal/lean-toolchain", + "repository": "fixture/collector-contract", + "sha256": "d5edba4e4b8faad9c1baeadb265716d20d03be4d1a2647dc5e35b0c0325bea7b" + } + ], + "compiler_identity": { + "executable": { + "bytes": 32, + "sha256": "f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00" + }, + "version_output": { + "bytes": 46, + "sha256": "09ae09205b0965c3841e1e334f268c5a6f7baf45eddad66cd0398d6fd9850e55" + } + }, + "dependencies": [ + { + "name": "a_fixture", + "revision": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + }, + { + "name": "z_fixture", + "revision": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" + } + ], + "dependency_lock": { + "bytes": 672, + "git_blob": "1dfc2ed4c155de7c1ca5dc2ca4171dccea3b1c5d", + "kind": "snapshot", + "path": "formal/lake-manifest.json", + "repository": "fixture/collector-contract", + "sha256": "5ade86188a7c4f0ca0f4254318100cc7930d514375c4a256551c9254b84b2658" + }, + "options": [ + "autoImplicit=false", + "maxRecDepth=128" + ], + "print_options": [ + "pp.explicit=true", + "pp.universes=true" + ], + "producer_sources": [ + { + "bytes": 73, + "git_blob": "83fad939382bf3c996a5b707ca3f69f1fc25a02f", + "kind": "snapshot", + "path": "tools/formal_gate_check.py", + "repository": "fixture/collector-contract", + "sha256": "698870017e3fde8a8c5743a2a6b2e9ff6a2a93cc78f0284546049794141542c4" + }, + { + "kind": "origin", + "ref": { + "bytes": 73, + "commit": "4444444444444444444444444444444444444444", + "git_blob": "8eed3c0a0318245082c027b7a006cf5d853f5ddc", + "path": "control/native-workflow.yml", + "repository": "fixture/control", + "sha256": "a768034663901091e4bd85420c43fd98ffabce3ce1f9ed17327a918e11fa45dd" + } + }, + { + "kind": "origin", + "ref": { + "bytes": 56, + "commit": "4444444444444444444444444444444444444444", + "git_blob": "cec033cc05bd392aa103ca10838d9db8c5cda786", + "path": "control/supervisor.py", + "repository": "fixture/control", + "sha256": "ae4d3070f92e31d2f8c662eded4226e987630bf7a8e2cf307f5d40016b0106f1" + } + } + ], + "runtime_identity": { + "executables": [ + { + "content": { + "bytes": 32, + "sha256": "f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00" + }, + "name": "lean" + }, + { + "content": { + "bytes": 38, + "sha256": "b1a11ede32499568db933c8703d668015ef50342193338fd2e9fec59913e9be0" + }, + "name": "python" + } + ], + "image_manifest": null, + "platform": "synthetic-linux-amd64-nonimage" + }, + "toolchain": "leanprover/lean4:v4.34.1" + }, + "format": "main-formal-gate/v1", + "manifest_contract_sha256": "ff592c9cbfc46b0376bb4ca7a33608e858ec9112352dad416bc4b793a1a583d9", + "module_content_identity": { + "bytes": 56, + "git_blob": "1e604667139c6d43c69c0af76160c2374b5ef65c", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d" + }, + "native_repository": "fixture/collector-contract", + "package": { + "declared_name": "Fixture", + "manifest_path": "formal/manifest.json" + }, + "scope_content_identity": { + "import_files": [ + { + "bytes": 59, + "git_blob": "02e8e595beb0686b7cbc722923d2dd679552b2a0", + "kind": "snapshot", + "path": "formal/Fixture/Base.lean", + "repository": "fixture/collector-contract", + "sha256": "dc90d249b1695b7048e28233959e8aa5511f9f93dc1984be5a0be0989ec99683" + }, + { + "bytes": 28, + "git_blob": "ec04f5b06cd1556280b6214bf6247dff75ab1a6f", + "kind": "snapshot", + "path": "formal/Fixture/Extra.lean", + "repository": "fixture/collector-contract", + "sha256": "c8fe60595798b75c502b37d5e92b44a23a37a285a904cbe2552078826af7a1f7" + } + ], + "scope_files": [ + { + "bytes": 73, + "git_blob": "97d8569986750f071d006023b656b2651b263c73", + "kind": "snapshot", + "path": "formal/GLOSSARY.md", + "repository": "fixture/collector-contract", + "sha256": "554783837178438d8c9cac728e8be4ba8edabadfc64e736227ae9e0e8f9293bd" + }, + { + "bytes": 92, + "git_blob": "cda22816532dfb264a8739cffc16b6d41cbbbf5e", + "kind": "snapshot", + "path": "formal/SCOPE.md", + "repository": "fixture/collector-contract", + "sha256": "765aa85be38b913b07548a56f21c600749ea727a96cbeb99d345ea30f317731b" + } + ] + }, + "target": "Demo.t", + "type_content_bytes": null, + "type_content_sha256": null, + "unresolved_fields": [ + "type_content_bytes", + "type_content_sha256" + ] + }, + { + "accepted_formal_proof_selector": [], + "accepted_formal_statement_selector": [], + "compiler_dependency_options_identity": { + "build_config": [ + { + "bytes": 85, + "git_blob": "c31b8ba6189dc0872704f4ea910f468502b3934d", + "kind": "snapshot", + "path": "formal/Fixture.lean", + "repository": "fixture/collector-contract", + "sha256": "24766498266ca3327ab43ce2551807099a474324ad4d1c9f5f2e0052c4e11afa" + }, + { + "bytes": 65, + "git_blob": "225d58dbcbb1116179103c8637c26e25310687f8", + "kind": "snapshot", + "path": "formal/lakefile.toml", + "repository": "fixture/collector-contract", + "sha256": "66f41c071ca37d39d785a00d298ee2fb4f851b9d5a749d33928f97cbf405970b" + }, + { + "bytes": 25, + "git_blob": "ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5", + "kind": "snapshot", + "path": "formal/lean-toolchain", + "repository": "fixture/collector-contract", + "sha256": "d5edba4e4b8faad9c1baeadb265716d20d03be4d1a2647dc5e35b0c0325bea7b" + } + ], + "compiler_identity": { + "executable": { + "bytes": 32, + "sha256": "f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00" + }, + "version_output": { + "bytes": 46, + "sha256": "09ae09205b0965c3841e1e334f268c5a6f7baf45eddad66cd0398d6fd9850e55" + } + }, + "dependencies": [ + { + "name": "a_fixture", + "revision": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + }, + { + "name": "z_fixture", + "revision": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" + } + ], + "dependency_lock": { + "bytes": 672, + "git_blob": "1dfc2ed4c155de7c1ca5dc2ca4171dccea3b1c5d", + "kind": "snapshot", + "path": "formal/lake-manifest.json", + "repository": "fixture/collector-contract", + "sha256": "5ade86188a7c4f0ca0f4254318100cc7930d514375c4a256551c9254b84b2658" + }, + "options": [ + "autoImplicit=false", + "maxRecDepth=128" + ], + "print_options": [ + "pp.explicit=true", + "pp.universes=true" + ], + "producer_sources": [ + { + "bytes": 73, + "git_blob": "83fad939382bf3c996a5b707ca3f69f1fc25a02f", + "kind": "snapshot", + "path": "tools/formal_gate_check.py", + "repository": "fixture/collector-contract", + "sha256": "698870017e3fde8a8c5743a2a6b2e9ff6a2a93cc78f0284546049794141542c4" + }, + { + "kind": "origin", + "ref": { + "bytes": 73, + "commit": "4444444444444444444444444444444444444444", + "git_blob": "8eed3c0a0318245082c027b7a006cf5d853f5ddc", + "path": "control/native-workflow.yml", + "repository": "fixture/control", + "sha256": "a768034663901091e4bd85420c43fd98ffabce3ce1f9ed17327a918e11fa45dd" + } + }, + { + "kind": "origin", + "ref": { + "bytes": 56, + "commit": "4444444444444444444444444444444444444444", + "git_blob": "cec033cc05bd392aa103ca10838d9db8c5cda786", + "path": "control/supervisor.py", + "repository": "fixture/control", + "sha256": "ae4d3070f92e31d2f8c662eded4226e987630bf7a8e2cf307f5d40016b0106f1" + } + } + ], + "runtime_identity": { + "executables": [ + { + "content": { + "bytes": 32, + "sha256": "f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00" + }, + "name": "lean" + }, + { + "content": { + "bytes": 38, + "sha256": "b1a11ede32499568db933c8703d668015ef50342193338fd2e9fec59913e9be0" + }, + "name": "python" + } + ], + "image_manifest": null, + "platform": "synthetic-linux-amd64-nonimage" + }, + "toolchain": "leanprover/lean4:v4.34.1" + }, + "format": "main-formal-gate/v1", + "manifest_contract_sha256": "ff592c9cbfc46b0376bb4ca7a33608e858ec9112352dad416bc4b793a1a583d9", + "module_content_identity": { + "bytes": 63, + "git_blob": "f1f9e1c25e8e491bd10d931cd6d0a64e78da034f", + "kind": "snapshot", + "path": "formal/Fixture/Unlinked.lean", + "repository": "fixture/collector-contract", + "sha256": "31015cf8631441e3cb1554075e20247c7e31e8f4c16daabcec21ddc94557142e" + }, + "native_repository": "fixture/collector-contract", + "package": { + "declared_name": "Fixture", + "manifest_path": "formal/manifest.json" + }, + "scope_content_identity": { + "import_files": [ + { + "bytes": 59, + "git_blob": "02e8e595beb0686b7cbc722923d2dd679552b2a0", + "kind": "snapshot", + "path": "formal/Fixture/Base.lean", + "repository": "fixture/collector-contract", + "sha256": "dc90d249b1695b7048e28233959e8aa5511f9f93dc1984be5a0be0989ec99683" + }, + { + "bytes": 28, + "git_blob": "ec04f5b06cd1556280b6214bf6247dff75ab1a6f", + "kind": "snapshot", + "path": "formal/Fixture/Extra.lean", + "repository": "fixture/collector-contract", + "sha256": "c8fe60595798b75c502b37d5e92b44a23a37a285a904cbe2552078826af7a1f7" + } + ], + "scope_files": [ + { + "bytes": 73, + "git_blob": "97d8569986750f071d006023b656b2651b263c73", + "kind": "snapshot", + "path": "formal/GLOSSARY.md", + "repository": "fixture/collector-contract", + "sha256": "554783837178438d8c9cac728e8be4ba8edabadfc64e736227ae9e0e8f9293bd" + }, + { + "bytes": 92, + "git_blob": "cda22816532dfb264a8739cffc16b6d41cbbbf5e", + "kind": "snapshot", + "path": "formal/SCOPE.md", + "repository": "fixture/collector-contract", + "sha256": "765aa85be38b913b07548a56f21c600749ea727a96cbeb99d345ea30f317731b" + } + ] + }, + "target": "Demo.unlinked", + "type_content_bytes": null, + "type_content_sha256": null, + "unresolved_fields": [ + "type_content_bytes", + "type_content_sha256" + ] + } + ] + }, + "expected_diagnostic_sha256": "158678be9458343d9e280e20fbbe11805becbb6ca594ab85fcd69028f444627c", + "expected_issues": [ + "SYNTHETIC_AUTHORITY_UNQUALIFIED", + "TYPE_RECORD_UNAVAILABLE" + ], + "kind": "SYNTHETIC_TEST_BOUNDARY_PROFILE_R01", + "membership": { + "domain_id": "fixture-only-domain", + "enumeration": "complete", + "native_dependencies": [ + { + "name": "a_fixture", + "revision": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + }, + { + "name": "z_fixture", + "revision": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" + } + ], + "native_format": "main-formal-gate/v1", + "native_repository": "fixture/collector-contract", + "native_targets": [ + "Demo.t", + "Demo.unlinked" + ], + "package": { + "declared_name": "Fixture", + "manifest_path": "formal/manifest.json" + }, + "print_options": [ + "pp.explicit=true", + "pp.universes=true" + ], + "producer_observation": { + "compiler_executable_ref": { + "bytes": 32, + "commit": "5555555555555555555555555555555555555555", + "git_blob": "26de5a68370962959c475018d1abc335c539eb09", + "path": "runtime/lean", + "repository": "fixture/runtime", + "sha256": "f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00" + }, + "compiler_version_ref": { + "bytes": 46, + "commit": "5555555555555555555555555555555555555555", + "git_blob": "57472d4b88ba3e2be8cb4f78ade6f9310a216e28", + "path": "runtime/lean-version.txt", + "repository": "fixture/runtime", + "sha256": "09ae09205b0965c3841e1e334f268c5a6f7baf45eddad66cd0398d6fd9850e55" + }, + "dependencies": [ + { + "name": "a_fixture", + "revision": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + }, + { + "name": "z_fixture", + "revision": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" + } + ], + "dependency_lock_ref": { + "bytes": 672, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "1dfc2ed4c155de7c1ca5dc2ca4171dccea3b1c5d", + "path": "formal/lake-manifest.json", + "repository": "fixture/collector-contract", + "sha256": "5ade86188a7c4f0ca0f4254318100cc7930d514375c4a256551c9254b84b2658" + }, + "format": "main-formal-gate/v1", + "options": [ + "autoImplicit=false", + "maxRecDepth=128" + ], + "print_options": [ + "pp.explicit=true", + "pp.universes=true" + ], + "runtime_executable_refs": [ + { + "name": "lean", + "ref": { + "bytes": 32, + "commit": "5555555555555555555555555555555555555555", + "git_blob": "26de5a68370962959c475018d1abc335c539eb09", + "path": "runtime/lean", + "repository": "fixture/runtime", + "sha256": "f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00" + } + }, + { + "name": "python", + "ref": { + "bytes": 38, + "commit": "5555555555555555555555555555555555555555", + "git_blob": "69f854d164664d92f0ffd245ff2854654c081ddf", + "path": "runtime/python", + "repository": "fixture/runtime", + "sha256": "b1a11ede32499568db933c8703d668015ef50342193338fd2e9fec59913e9be0" + } + } + ], + "runtime_identity": { + "executables": [ + { + "content": { + "bytes": 32, + "sha256": "f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00" + }, + "name": "lean" + }, + { + "content": { + "bytes": 38, + "sha256": "b1a11ede32499568db933c8703d668015ef50342193338fd2e9fec59913e9be0" + }, + "name": "python" + } + ], + "image_manifest": null, + "platform": "synthetic-linux-amd64-nonimage" + }, + "toolchain": "leanprover/lean4:v4.34.1" + }, + "producer_observation_ref": { + "bytes": 2105, + "commit": "4444444444444444444444444444444444444444", + "git_blob": "4d41580a00ca094e082d5f7a40b0ee2f12ee7b3e", + "path": "captures/producer-observation.json", + "repository": "fixture/control", + "sha256": "0ff91996ab7675f92ef7eb35f9525f8897977af1a12333b7ccb57e9aa0073891" + }, + "qualification": { + "mapping": "UNQUALIFIED", + "mode": "SYNTHETIC_STRUCTURE_ONLY", + "native_execution": "UNQUALIFIED", + "native_source": "UNQUALIFIED", + "review": "UNQUALIFIED", + "scientific_status_authority": false + }, + "role_inputs": { + "build_config": [ + { + "bytes": 85, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "c31b8ba6189dc0872704f4ea910f468502b3934d", + "path": "formal/Fixture.lean", + "repository": "fixture/collector-contract", + "sha256": "24766498266ca3327ab43ce2551807099a474324ad4d1c9f5f2e0052c4e11afa" + }, + { + "bytes": 65, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "225d58dbcbb1116179103c8637c26e25310687f8", + "path": "formal/lakefile.toml", + "repository": "fixture/collector-contract", + "sha256": "66f41c071ca37d39d785a00d298ee2fb4f851b9d5a749d33928f97cbf405970b" + }, + { + "bytes": 25, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5", + "path": "formal/lean-toolchain", + "repository": "fixture/collector-contract", + "sha256": "d5edba4e4b8faad9c1baeadb265716d20d03be4d1a2647dc5e35b0c0325bea7b" + } + ], + "import_files": [ + { + "bytes": 59, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "02e8e595beb0686b7cbc722923d2dd679552b2a0", + "path": "formal/Fixture/Base.lean", + "repository": "fixture/collector-contract", + "sha256": "dc90d249b1695b7048e28233959e8aa5511f9f93dc1984be5a0be0989ec99683" + }, + { + "bytes": 28, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "ec04f5b06cd1556280b6214bf6247dff75ab1a6f", + "path": "formal/Fixture/Extra.lean", + "repository": "fixture/collector-contract", + "sha256": "c8fe60595798b75c502b37d5e92b44a23a37a285a904cbe2552078826af7a1f7" + } + ], + "producer_sources": [ + { + "bytes": 73, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "83fad939382bf3c996a5b707ca3f69f1fc25a02f", + "path": "tools/formal_gate_check.py", + "repository": "fixture/collector-contract", + "sha256": "698870017e3fde8a8c5743a2a6b2e9ff6a2a93cc78f0284546049794141542c4" + }, + { + "bytes": 56, + "commit": "4444444444444444444444444444444444444444", + "git_blob": "cec033cc05bd392aa103ca10838d9db8c5cda786", + "path": "control/supervisor.py", + "repository": "fixture/control", + "sha256": "ae4d3070f92e31d2f8c662eded4226e987630bf7a8e2cf307f5d40016b0106f1" + }, + { + "bytes": 73, + "commit": "4444444444444444444444444444444444444444", + "git_blob": "8eed3c0a0318245082c027b7a006cf5d853f5ddc", + "path": "control/native-workflow.yml", + "repository": "fixture/control", + "sha256": "a768034663901091e4bd85420c43fd98ffabce3ce1f9ed17327a918e11fa45dd" + } + ], + "scope_files": [ + { + "bytes": 92, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "cda22816532dfb264a8739cffc16b6d41cbbbf5e", + "path": "formal/SCOPE.md", + "repository": "fixture/collector-contract", + "sha256": "765aa85be38b913b07548a56f21c600749ea727a96cbeb99d345ea30f317731b" + }, + { + "bytes": 73, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "97d8569986750f071d006023b656b2651b263c73", + "path": "formal/GLOSSARY.md", + "repository": "fixture/collector-contract", + "sha256": "554783837178438d8c9cac728e8be4ba8edabadfc64e736227ae9e0e8f9293bd" + } + ] + }, + "runtime_kind": "non-image", + "schema_version": 1, + "side": "candidate", + "snapshot": { + "commit": "3333333333333333333333333333333333333333", + "repository": "fixture/collector-contract", + "tree": "cccccccccccccccccccccccccccccccccccccccc" + }, + "sources": [ + { + "native_mode": "100644", + "raw_base64": "aW1wb3J0IEZpeHR1cmUuQmFzZQp0aGVvcmVtIERlbW8udCA6IFRydWUgOj0gYnkgdHJpdmlhbAo=", + "ref": { + "bytes": 56, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "1e604667139c6d43c69c0af76160c2374b5ef65c", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d" + }, + "role": "formal_module", + "side": "candidate" + }, + { + "native_mode": "100644", + "raw_base64": "aW1wb3J0IEZpeHR1cmUuQmFzZQp0aGVvcmVtIERlbW8udW5saW5rZWQgOiBUcnVlIDo9IGJ5IHRyaXZpYWwK", + "ref": { + "bytes": 63, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "f1f9e1c25e8e491bd10d931cd6d0a64e78da034f", + "path": "formal/Fixture/Unlinked.lean", + "repository": "fixture/collector-contract", + "sha256": "31015cf8631441e3cb1554075e20247c7e31e8f4c16daabcec21ddc94557142e" + }, + "role": "formal_module", + "side": "candidate" + }, + { + "native_mode": "100644", + "raw_base64": "aW1wb3J0IEZpeHR1cmUuRXh0cmEKZGVmIGZpeHR1cmVCYXNlIDogTmF0IDo9IGZpeHR1cmVFeHRyYQo=", + "ref": { + "bytes": 59, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "02e8e595beb0686b7cbc722923d2dd679552b2a0", + "path": "formal/Fixture/Base.lean", + "repository": "fixture/collector-contract", + "sha256": "dc90d249b1695b7048e28233959e8aa5511f9f93dc1984be5a0be0989ec99683" + }, + "role": "import_file", + "side": "candidate" + }, + { + "native_mode": "100644", + "raw_base64": "ZGVmIGZpeHR1cmVFeHRyYSA6IE5hdCA6PSAxCg==", + "ref": { + "bytes": 28, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "ec04f5b06cd1556280b6214bf6247dff75ab1a6f", + "path": "formal/Fixture/Extra.lean", + "repository": "fixture/collector-contract", + "sha256": "c8fe60595798b75c502b37d5e92b44a23a37a285a904cbe2552078826af7a1f7" + }, + "role": "import_file", + "side": "candidate" + }, + { + "native_mode": "100644", + "raw_base64": "Rml4dHVyZSBkb21haW4gb25seS4gQm90aCBuYXRpdmUgdGFyZ2V0cyBhcmUgZW51bWVyYXRlZDsgRGVtby51bmxpbmtlZCBoYXMgbm8gbWFwcGluZyBsaW5rLgo=", + "ref": { + "bytes": 92, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "cda22816532dfb264a8739cffc16b6d41cbbbf5e", + "path": "formal/SCOPE.md", + "repository": "fixture/collector-contract", + "sha256": "765aa85be38b913b07548a56f21c600749ea727a96cbeb99d345ea30f317731b" + }, + "role": "scope_file", + "side": "candidate" + }, + { + "native_mode": "100644", + "raw_base64": "Rml4dHVyZS50IGFuZCBGaXh0dXJlLnVubGlua2VkIGFyZSBzeW50aGV0aWMgc291cmNlLXNoYXBlIGV4YW1wbGVzIG9ubHkuCg==", + "ref": { + "bytes": 73, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "97d8569986750f071d006023b656b2651b263c73", + "path": "formal/GLOSSARY.md", + "repository": "fixture/collector-contract", + "sha256": "554783837178438d8c9cac728e8be4ba8edabadfc64e736227ae9e0e8f9293bd" + }, + "role": "scope_file", + "side": "candidate" + }, + { + "native_mode": "100644", + "raw_base64": "U3ludGhldGljIE1haW4tZm9ybWF0IHBhY2thZ2UuIE5vIGV4ZWN1dGlvbiBvciBzY2llbnRpZmljIGV2aWRlbmNlLgo=", + "ref": { + "bytes": 68, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "ccd9ab7b2923cf87d413ef147581e7ccbf1c7749", + "path": "formal/README.md", + "repository": "fixture/collector-contract", + "sha256": "17500df1abb61d58c4d215052da106bfffcd90ccf5568c53707ac1debc9d9a4c" + }, + "role": "package_document", + "side": "candidate" + }, + { + "native_mode": "100644", + "raw_base64": "U3ludGhldGljIHVuYm91bmQgZG9jdW1lbnQuIEFjdHVhbCBvcmlnaW5hbCByZXZpZXcgYW5kIGFsaWdubWVudCBhY2NlcHRhbmNlIGFyZSBhYnNlbnQuCg==", + "ref": { + "bytes": 88, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "f8937eba9c480be801a36cb09962a87909bc9f7b", + "path": "formal/ALIGNMENT.md", + "repository": "fixture/collector-contract", + "sha256": "0680ae897ed0719b5c7e711028f8dad33c1a2c1f0a4f0f90d2f2e4d33259d38a" + }, + "role": "unbound_document", + "side": "candidate" + }, + { + "native_mode": "100644", + "raw_base64": "bGVhbnByb3Zlci9sZWFuNDp2NC4zNC4xCg==", + "ref": { + "bytes": 25, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5", + "path": "formal/lean-toolchain", + "repository": "fixture/collector-contract", + "sha256": "d5edba4e4b8faad9c1baeadb265716d20d03be4d1a2647dc5e35b0c0325bea7b" + }, + "role": "build_config", + "side": "candidate" + }, + { + "native_mode": "100644", + "raw_base64": "bmFtZSA9ICJGaXh0dXJlIgp2ZXJzaW9uID0gIjAuMC4wIgpbW2xlYW5fbGliXV0KbmFtZSA9ICJGaXh0dXJlIgo=", + "ref": { + "bytes": 65, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "225d58dbcbb1116179103c8637c26e25310687f8", + "path": "formal/lakefile.toml", + "repository": "fixture/collector-contract", + "sha256": "66f41c071ca37d39d785a00d298ee2fb4f851b9d5a749d33928f97cbf405970b" + }, + "role": "build_config", + "side": "candidate" + }, + { + "native_mode": "100644", + "raw_base64": "aW1wb3J0IEZpeHR1cmUuRGVtbwppbXBvcnQgRml4dHVyZS5VbmxpbmtlZAppbXBvcnQgRml4dHVyZS5CYXNlCmltcG9ydCBGaXh0dXJlLkV4dHJhCg==", + "ref": { + "bytes": 85, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "c31b8ba6189dc0872704f4ea910f468502b3934d", + "path": "formal/Fixture.lean", + "repository": "fixture/collector-contract", + "sha256": "24766498266ca3327ab43ce2551807099a474324ad4d1c9f5f2e0052c4e11afa" + }, + "role": "build_config", + "side": "candidate" + }, + { + "native_mode": "100644", + "raw_base64": "eyJsYWtlRGlyIjoiLmxha2UiLCJuYW1lIjoiRml4dHVyZSIsInBhY2thZ2VzIjpbeyJjb25maWdGaWxlIjoibGFrZWZpbGUudG9tbCIsImluaGVyaXRlZCI6ZmFsc2UsImlucHV0UmV2IjoiYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYSIsIm1hbmlmZXN0RmlsZSI6Imxha2UtbWFuaWZlc3QuanNvbiIsIm5hbWUiOiJhX2ZpeHR1cmUiLCJyZXYiOiJhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhIiwic2NvcGUiOiIiLCJzdWJEaXIiOm51bGwsInR5cGUiOiJnaXQiLCJ1cmwiOiJodHRwczovL2ZpeHR1cmUuaW52YWxpZC9hX2ZpeHR1cmUifSx7ImNvbmZpZ0ZpbGUiOiJsYWtlZmlsZS50b21sIiwiaW5oZXJpdGVkIjpmYWxzZSwiaW5wdXRSZXYiOiJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiIiwibWFuaWZlc3RGaWxlIjoibGFrZS1tYW5pZmVzdC5qc29uIiwibmFtZSI6InpfZml4dHVyZSIsInJldiI6ImJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmIiLCJzY29wZSI6IiIsInN1YkRpciI6bnVsbCwidHlwZSI6ImdpdCIsInVybCI6Imh0dHBzOi8vZml4dHVyZS5pbnZhbGlkL3pfZml4dHVyZSJ9XSwicGFja2FnZXNEaXIiOiIubGFrZS9wYWNrYWdlcyIsInZlcnNpb24iOiIxLjEuMCJ9", + "ref": { + "bytes": 672, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "1dfc2ed4c155de7c1ca5dc2ca4171dccea3b1c5d", + "path": "formal/lake-manifest.json", + "repository": "fixture/collector-contract", + "sha256": "5ade86188a7c4f0ca0f4254318100cc7930d514375c4a256551c9254b84b2658" + }, + "role": "dependency_lock", + "side": "candidate" + }, + { + "native_mode": "100644", + "raw_base64": "IyBTeW50aGV0aWMgYnl0ZSBmaXh0dXJlIGZvciBwcm9kdWNlci1zb3VyY2UgcHJvamVjdGlvbjsgbmV2ZXIgZXhlY3V0ZWQuCg==", + "ref": { + "bytes": 73, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "83fad939382bf3c996a5b707ca3f69f1fc25a02f", + "path": "tools/formal_gate_check.py", + "repository": "fixture/collector-contract", + "sha256": "698870017e3fde8a8c5743a2a6b2e9ff6a2a93cc78f0284546049794141542c4" + }, + "role": "producer_source", + "side": "candidate" + }, + { + "native_mode": "100644", + "raw_base64": "IyBTeW50aGV0aWMgbmF0aXZlIGJvdW5kLWZpbGUgZml4dHVyZTsgbmV2ZXIgZXhlY3V0ZWQuCg==", + "ref": { + "bytes": 55, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "34e57e054d25686df0252a1ac538bc7974f903de", + "path": "tests/test_formal_gate.py", + "repository": "fixture/collector-contract", + "sha256": "f1d94482197a5225627d8db0d426043f4db546f647de4e76571ae148f0f7fa63" + }, + "role": "package_test", + "side": "candidate" + }, + { + "native_mode": "100644", + "raw_base64": "Rml4dHVyZSBsaW5rZWQgc3RhdGVtZW50LgpGaXh0dXJlIHVubGlua2VkIHN0YXRlbWVudC4KTm8gc2NpZW50aWZpYyBjbGFpbS4K", + "ref": { + "bytes": 75, + "commit": "6666666666666666666666666666666666666666", + "git_blob": "1d2610908271710703c4d30ad9f9685eea55eebd", + "path": "notes/fixture.md", + "repository": "fixture/informal", + "sha256": "cf2553aa0f294e046e50cfd5b10133819f2dff37117035f0269b1c33de408c58" + }, + "role": "informal_origin", + "side": "origin" + }, + { + "native_mode": "100644", + "raw_base64": "Rml4dHVyZSBsaW5rZWQgc3RhdGVtZW50LgpGaXh0dXJlIHVubGlua2VkIHN0YXRlbWVudC4KTm8gc2NpZW50aWZpYyBjbGFpbS4K", + "ref": { + "bytes": 75, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "1d2610908271710703c4d30ad9f9685eea55eebd", + "path": "formal/sources/fixture/NOTE.md", + "repository": "fixture/collector-contract", + "sha256": "cf2553aa0f294e046e50cfd5b10133819f2dff37117035f0269b1c33de408c58" + }, + "role": "checked_local_copy", + "side": "candidate" + }, + { + "native_mode": "100644", + "raw_base64": "IyBTeW50aGV0aWMgaW1tdXRhYmxlIHByb2R1Y2VyIHdvcmtmbG93IGJ5dGVzOyBuZXZlciBwYXJzZWQgb3IgZXhlY3V0ZWQuCg==", + "ref": { + "bytes": 73, + "commit": "4444444444444444444444444444444444444444", + "git_blob": "8eed3c0a0318245082c027b7a006cf5d853f5ddc", + "path": "control/native-workflow.yml", + "repository": "fixture/control", + "sha256": "a768034663901091e4bd85420c43fd98ffabce3ce1f9ed17327a918e11fa45dd" + }, + "role": "producer_source", + "side": "origin" + }, + { + "native_mode": "100644", + "raw_base64": "IyBTeW50aGV0aWMgaW1tdXRhYmxlIHN1cGVydmlzb3IgYnl0ZXM7IG5ldmVyIGV4ZWN1dGVkLgo=", + "ref": { + "bytes": 56, + "commit": "4444444444444444444444444444444444444444", + "git_blob": "cec033cc05bd392aa103ca10838d9db8c5cda786", + "path": "control/supervisor.py", + "repository": "fixture/control", + "sha256": "ae4d3070f92e31d2f8c662eded4226e987630bf7a8e2cf307f5d40016b0106f1" + }, + "role": "producer_source", + "side": "origin" + }, + { + "native_mode": "100644", + "raw_base64": "c3ludGhldGljIGxlYW4gZXhlY3V0YWJsZSBieXRlcwA=", + "ref": { + "bytes": 32, + "commit": "5555555555555555555555555555555555555555", + "git_blob": "26de5a68370962959c475018d1abc335c539eb09", + "path": "runtime/lean", + "repository": "fixture/runtime", + "sha256": "f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00" + }, + "role": "compiler_binary", + "side": "origin" + }, + { + "native_mode": "100644", + "raw_base64": "TGVhbiAodmVyc2lvbiA0LjM0LjEsIHN5bnRoZXRpYyBmaXh0dXJlIG9ubHkpCg==", + "ref": { + "bytes": 46, + "commit": "5555555555555555555555555555555555555555", + "git_blob": "57472d4b88ba3e2be8cb4f78ade6f9310a216e28", + "path": "runtime/lean-version.txt", + "repository": "fixture/runtime", + "sha256": "09ae09205b0965c3841e1e334f268c5a6f7baf45eddad66cd0398d6fd9850e55" + }, + "role": "compiler_version_output", + "side": "origin" + }, + { + "native_mode": "100644", + "raw_base64": "c3ludGhldGljIHN1cGVydmlzb3IgZXhlY3V0YWJsZSBieXRlcwA=", + "ref": { + "bytes": 38, + "commit": "5555555555555555555555555555555555555555", + "git_blob": "69f854d164664d92f0ffd245ff2854654c081ddf", + "path": "runtime/python", + "repository": "fixture/runtime", + "sha256": "b1a11ede32499568db933c8703d668015ef50342193338fd2e9fec59913e9be0" + }, + "role": "runtime_executable", + "side": "origin" + }, + { + "native_mode": "100644", + "raw_base64": "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", + "ref": { + "bytes": 3253, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "79003b67ab854170a94463568166ebb2f1d182f1", + "path": "formal/manifest.json", + "repository": "fixture/collector-contract", + "sha256": "ff592c9cbfc46b0376bb4ca7a33608e858ec9112352dad416bc4b793a1a583d9" + }, + "role": "native_manifest", + "side": "candidate" + }, + { + "native_mode": "100644", + "raw_base64": "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", + "ref": { + "bytes": 2105, + "commit": "4444444444444444444444444444444444444444", + "git_blob": "4d41580a00ca094e082d5f7a40b0ee2f12ee7b3e", + "path": "captures/producer-observation.json", + "repository": "fixture/control", + "sha256": "0ff91996ab7675f92ef7eb35f9525f8897977af1a12333b7ccb57e9aa0073891" + }, + "role": "producer_observation", + "side": "origin" + } + ], + "target_inputs": [ + { + "imports": [ + { + "bytes": 59, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "02e8e595beb0686b7cbc722923d2dd679552b2a0", + "path": "formal/Fixture/Base.lean", + "repository": "fixture/collector-contract", + "sha256": "dc90d249b1695b7048e28233959e8aa5511f9f93dc1984be5a0be0989ec99683" + }, + { + "bytes": 28, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "ec04f5b06cd1556280b6214bf6247dff75ab1a6f", + "path": "formal/Fixture/Extra.lean", + "repository": "fixture/collector-contract", + "sha256": "c8fe60595798b75c502b37d5e92b44a23a37a285a904cbe2552078826af7a1f7" + } + ], + "target": "Demo.t" + }, + { + "imports": [ + { + "bytes": 59, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "02e8e595beb0686b7cbc722923d2dd679552b2a0", + "path": "formal/Fixture/Base.lean", + "repository": "fixture/collector-contract", + "sha256": "dc90d249b1695b7048e28233959e8aa5511f9f93dc1984be5a0be0989ec99683" + }, + { + "bytes": 28, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "ec04f5b06cd1556280b6214bf6247dff75ab1a6f", + "path": "formal/Fixture/Extra.lean", + "repository": "fixture/collector-contract", + "sha256": "c8fe60595798b75c502b37d5e92b44a23a37a285a904cbe2552078826af7a1f7" + } + ], + "target": "Demo.unlinked" + } + ] + }, + "native_wire_negative_examples": [ + { + "id": "native_root_extra", + "path": [ + "unadmitted" + ], + "value": "forged-extra" + }, + { + "id": "native_target_extra", + "path": [ + "targets", + 0, + "unadmitted" + ], + "value": "forged-extra" + }, + { + "id": "native_origin_extra", + "path": [ + "sources", + 0, + "unadmitted" + ], + "value": "forged-extra" + }, + { + "id": "native_coordination_extra", + "path": [ + "coordination", + "unadmitted" + ], + "value": "forged-extra" + }, + { + "id": "native_author_extra", + "path": [ + "author", + "unadmitted" + ], + "value": "forged-extra" + }, + { + "id": "native_negative_extra", + "path": [ + "negative_controls", + "false_fixture_statement", + "unadmitted" + ], + "value": "forged-extra" + }, + { + "id": "native_package_wrong_type", + "path": [ + "package" + ], + "value": {} + }, + { + "id": "native_target_module_null", + "path": [ + "targets", + 0, + "module" + ], + "value": null + }, + { + "id": "native_origin_bytes_bool", + "path": [ + "sources", + 0, + "bytes" + ], + "value": true + }, + { + "id": "native_dependency_revision_bool", + "path": [ + "dependency_revisions", + "a_fixture" + ], + "value": true + }, + { + "id": "native_target_string_array_is_other_format", + "path": [ + "targets" + ], + "value": [ + "Demo.t", + "Demo.unlinked" + ] + } + ], + "origin_commit_oracles": [ + { + "bytes": 3141, + "canonical_ascii_preimage": "{\"domain\":\"formal-regression-inventory/v1\",\"domain_id\":\"fixture-only-domain\",\"targets\":[{\"accepted_formal_proof_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":35,\"sha256\":\"f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98\",\"source\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"start_byte\":25}}],\"accepted_formal_statement_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":21,\"sha256\":\"1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7\",\"source\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"start_byte\":0}}],\"compiler_dependency_options_identity\":{\"build_config\":[],\"compiler_identity\":{\"executable\":{\"bytes\":23,\"sha256\":\"4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3\"},\"version_output\":{\"bytes\":27,\"sha256\":\"02adc609bd41e61fbfaedd8c89919c9cc125e3cb9f806c4208f757e1819bd78f\"}},\"dependencies\":[{\"name\":\"fixture_dep\",\"revision\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}],\"dependency_lock\":{\"bytes\":86,\"git_blob\":\"61ec800f4939eb07f270dfb49e9082cb332ed2d1\",\"kind\":\"snapshot\",\"path\":\"formal/lake-manifest.json\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"1ab9294e46112743a4489f401e0ba4dcd6d8e595458ede8b2a71958593774be4\"},\"options\":[],\"print_options\":[\"pp.explicit=true\"],\"producer_sources\":[{\"kind\":\"origin\",\"ref\":{\"bytes\":1,\"commit\":\"7777777777777777777777777777777777777777\",\"git_blob\":\"6666666666666666666666666666666666666666\",\"path\":\"control/producer.py\",\"repository\":\"fixture/control\",\"sha256\":\"7777777777777777777777777777777777777777777777777777777777777777\"}}],\"runtime_identity\":{\"executables\":[{\"content\":{\"bytes\":23,\"sha256\":\"4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3\"},\"name\":\"compiler\"}],\"image_manifest\":null,\"platform\":\"synthetic-fixture-only\"},\"toolchain\":\"fixture-toolchain-1\"},\"format\":\"main-formal-gate/v1\",\"manifest_contract_sha256\":\"23431134396d8740104bbfd88ab2cadd0192f614422cb86a64fb7ab174973a33\",\"module_content_identity\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"native_repository\":\"fixture/collector-contract\",\"package\":{\"declared_name\":\"Fixture\",\"manifest_path\":\"formal/manifest.json\"},\"scope_content_identity\":{\"import_files\":[],\"scope_files\":[{\"bytes\":21,\"git_blob\":\"ad8dd765494201f2801c519e4968fd7d5e9f681b\",\"kind\":\"snapshot\",\"path\":\"formal/SCOPE.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"f02d203cd02fe51dce38f860a48502322f39c852cc5668b1fa4454ac9c0a9a85\"}]},\"target\":\"Demo.t\",\"type_content_bytes\":14,\"type_content_sha256\":\"41f2e67cfbe0ed463361466a589f2412c29e892507bee03d527fbd556d87c5ef\",\"unresolved_fields\":[]}]}", + "commit": "7777777777777777777777777777777777777777", + "sha256": "ec5c0464eb3b3ac437c8309d5a9b182530eae67547689a5c05579281268d136d" + }, + { + "bytes": 3141, + "canonical_ascii_preimage": "{\"domain\":\"formal-regression-inventory/v1\",\"domain_id\":\"fixture-only-domain\",\"targets\":[{\"accepted_formal_proof_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":35,\"sha256\":\"f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98\",\"source\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"start_byte\":25}}],\"accepted_formal_statement_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":21,\"sha256\":\"1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7\",\"source\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"start_byte\":0}}],\"compiler_dependency_options_identity\":{\"build_config\":[],\"compiler_identity\":{\"executable\":{\"bytes\":23,\"sha256\":\"4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3\"},\"version_output\":{\"bytes\":27,\"sha256\":\"02adc609bd41e61fbfaedd8c89919c9cc125e3cb9f806c4208f757e1819bd78f\"}},\"dependencies\":[{\"name\":\"fixture_dep\",\"revision\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}],\"dependency_lock\":{\"bytes\":86,\"git_blob\":\"61ec800f4939eb07f270dfb49e9082cb332ed2d1\",\"kind\":\"snapshot\",\"path\":\"formal/lake-manifest.json\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"1ab9294e46112743a4489f401e0ba4dcd6d8e595458ede8b2a71958593774be4\"},\"options\":[],\"print_options\":[\"pp.explicit=true\"],\"producer_sources\":[{\"kind\":\"origin\",\"ref\":{\"bytes\":1,\"commit\":\"8888888888888888888888888888888888888888\",\"git_blob\":\"6666666666666666666666666666666666666666\",\"path\":\"control/producer.py\",\"repository\":\"fixture/control\",\"sha256\":\"7777777777777777777777777777777777777777777777777777777777777777\"}}],\"runtime_identity\":{\"executables\":[{\"content\":{\"bytes\":23,\"sha256\":\"4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3\"},\"name\":\"compiler\"}],\"image_manifest\":null,\"platform\":\"synthetic-fixture-only\"},\"toolchain\":\"fixture-toolchain-1\"},\"format\":\"main-formal-gate/v1\",\"manifest_contract_sha256\":\"23431134396d8740104bbfd88ab2cadd0192f614422cb86a64fb7ab174973a33\",\"module_content_identity\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"native_repository\":\"fixture/collector-contract\",\"package\":{\"declared_name\":\"Fixture\",\"manifest_path\":\"formal/manifest.json\"},\"scope_content_identity\":{\"import_files\":[],\"scope_files\":[{\"bytes\":21,\"git_blob\":\"ad8dd765494201f2801c519e4968fd7d5e9f681b\",\"kind\":\"snapshot\",\"path\":\"formal/SCOPE.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"f02d203cd02fe51dce38f860a48502322f39c852cc5668b1fa4454ac9c0a9a85\"}]},\"target\":\"Demo.t\",\"type_content_bytes\":14,\"type_content_sha256\":\"41f2e67cfbe0ed463361466a589f2412c29e892507bee03d527fbd556d87c5ef\",\"unresolved_fields\":[]}]}", + "commit": "8888888888888888888888888888888888888888", + "sha256": "c0df40e646762921112000930d9dae597ef08bd8e03f361dd9f0a6de5b34fe99" + } + ], + "policy_closed_object_examples": [ + { + "path": [ + "native_producer_policies", + 0, + "artifact_inventory_contract" + ], + "type": "ArtifactInventoryContract" + }, + { + "path": [ + "native_producer_policies", + 0, + "attempt_custody_contract" + ], + "type": "AttemptCustodyContract" + }, + { + "path": [ + "native_producer_policies", + 0, + "runtime_identity", + "executables", + 0, + "content" + ], + "type": "ByteContent" + }, + { + "path": [ + "native_producer_policies", + 0, + "dependency_policy", + "revisions", + 0 + ], + "type": "Dependency" + }, + { + "path": [ + "native_producer_policies", + 0, + "dependency_policy" + ], + "type": "DependencyPolicy" + }, + { + "path": [], + "type": "DiagnosticPolicy" + }, + { + "path": [ + "trusted_control_sources", + 0 + ], + "type": "GitRef" + }, + { + "path": [ + "limits" + ], + "type": "Limits" + }, + { + "path": [ + "native_producer_policies", + 0, + "runtime_identity", + "executables", + 0 + ], + "type": "NamedExecutableContent" + }, + { + "path": [ + "native_producer_policies", + 0 + ], + "type": "NativeProducerPolicy" + }, + { + "path": [ + "native_producer_policies", + 0, + "runtime_identity" + ], + "type": "RuntimeContent" + }, + { + "path": [ + "native_producer_policies", + 0, + "sandbox_contract" + ], + "type": "SandboxContract" + }, + { + "path": [ + "native_producer_policies", + 0, + "source_control_files" + ], + "type": "SourceControlFiles" + }, + { + "path": [ + "native_producer_policies", + 0, + "source_control_files", + "target_inputs", + 0 + ], + "type": "TargetInputs" + } + ], + "projection_order_oracles": { + "options": { + "bytes": 10556, + "canonical_ascii_preimage": "{\"domain\":\"formal-regression-inventory/v1\",\"domain_id\":\"fixture-only-domain\",\"targets\":[{\"accepted_formal_proof_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":55,\"sha256\":\"f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98\",\"source\":{\"bytes\":56,\"git_blob\":\"1e604667139c6d43c69c0af76160c2374b5ef65c\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d\"},\"start_byte\":45}},{\"link_id\":\"z-fixture-link\",\"selector\":{\"end_byte\":55,\"sha256\":\"f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98\",\"source\":{\"bytes\":56,\"git_blob\":\"1e604667139c6d43c69c0af76160c2374b5ef65c\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d\"},\"start_byte\":45}}],\"accepted_formal_statement_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":41,\"sha256\":\"1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7\",\"source\":{\"bytes\":56,\"git_blob\":\"1e604667139c6d43c69c0af76160c2374b5ef65c\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d\"},\"start_byte\":20}},{\"link_id\":\"z-fixture-link\",\"selector\":{\"end_byte\":41,\"sha256\":\"1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7\",\"source\":{\"bytes\":56,\"git_blob\":\"1e604667139c6d43c69c0af76160c2374b5ef65c\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d\"},\"start_byte\":20}}],\"compiler_dependency_options_identity\":{\"build_config\":[{\"bytes\":85,\"git_blob\":\"c31b8ba6189dc0872704f4ea910f468502b3934d\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"24766498266ca3327ab43ce2551807099a474324ad4d1c9f5f2e0052c4e11afa\"},{\"bytes\":65,\"git_blob\":\"225d58dbcbb1116179103c8637c26e25310687f8\",\"kind\":\"snapshot\",\"path\":\"formal/lakefile.toml\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"66f41c071ca37d39d785a00d298ee2fb4f851b9d5a749d33928f97cbf405970b\"},{\"bytes\":25,\"git_blob\":\"ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5\",\"kind\":\"snapshot\",\"path\":\"formal/lean-toolchain\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"d5edba4e4b8faad9c1baeadb265716d20d03be4d1a2647dc5e35b0c0325bea7b\"}],\"compiler_identity\":{\"executable\":{\"bytes\":32,\"sha256\":\"f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00\"},\"version_output\":{\"bytes\":46,\"sha256\":\"09ae09205b0965c3841e1e334f268c5a6f7baf45eddad66cd0398d6fd9850e55\"}},\"dependencies\":[{\"name\":\"a_fixture\",\"revision\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"},{\"name\":\"z_fixture\",\"revision\":\"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"}],\"dependency_lock\":{\"bytes\":672,\"git_blob\":\"1dfc2ed4c155de7c1ca5dc2ca4171dccea3b1c5d\",\"kind\":\"snapshot\",\"path\":\"formal/lake-manifest.json\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"5ade86188a7c4f0ca0f4254318100cc7930d514375c4a256551c9254b84b2658\"},\"options\":[\"maxRecDepth=128\",\"autoImplicit=false\"],\"print_options\":[\"pp.explicit=true\",\"pp.universes=true\"],\"producer_sources\":[{\"bytes\":73,\"git_blob\":\"83fad939382bf3c996a5b707ca3f69f1fc25a02f\",\"kind\":\"snapshot\",\"path\":\"tools/formal_gate_check.py\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"698870017e3fde8a8c5743a2a6b2e9ff6a2a93cc78f0284546049794141542c4\"},{\"kind\":\"origin\",\"ref\":{\"bytes\":73,\"commit\":\"4444444444444444444444444444444444444444\",\"git_blob\":\"8eed3c0a0318245082c027b7a006cf5d853f5ddc\",\"path\":\"control/native-workflow.yml\",\"repository\":\"fixture/control\",\"sha256\":\"a768034663901091e4bd85420c43fd98ffabce3ce1f9ed17327a918e11fa45dd\"}},{\"kind\":\"origin\",\"ref\":{\"bytes\":56,\"commit\":\"4444444444444444444444444444444444444444\",\"git_blob\":\"cec033cc05bd392aa103ca10838d9db8c5cda786\",\"path\":\"control/supervisor.py\",\"repository\":\"fixture/control\",\"sha256\":\"ae4d3070f92e31d2f8c662eded4226e987630bf7a8e2cf307f5d40016b0106f1\"}}],\"runtime_identity\":{\"executables\":[{\"content\":{\"bytes\":32,\"sha256\":\"f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00\"},\"name\":\"lean\"},{\"content\":{\"bytes\":38,\"sha256\":\"b1a11ede32499568db933c8703d668015ef50342193338fd2e9fec59913e9be0\"},\"name\":\"python\"}],\"image_manifest\":null,\"platform\":\"synthetic-linux-amd64-nonimage\"},\"toolchain\":\"leanprover/lean4:v4.34.1\"},\"format\":\"main-formal-gate/v1\",\"manifest_contract_sha256\":\"ff592c9cbfc46b0376bb4ca7a33608e858ec9112352dad416bc4b793a1a583d9\",\"module_content_identity\":{\"bytes\":56,\"git_blob\":\"1e604667139c6d43c69c0af76160c2374b5ef65c\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d\"},\"native_repository\":\"fixture/collector-contract\",\"package\":{\"declared_name\":\"Fixture\",\"manifest_path\":\"formal/manifest.json\"},\"scope_content_identity\":{\"import_files\":[{\"bytes\":59,\"git_blob\":\"02e8e595beb0686b7cbc722923d2dd679552b2a0\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Base.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"dc90d249b1695b7048e28233959e8aa5511f9f93dc1984be5a0be0989ec99683\"},{\"bytes\":28,\"git_blob\":\"ec04f5b06cd1556280b6214bf6247dff75ab1a6f\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Extra.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"c8fe60595798b75c502b37d5e92b44a23a37a285a904cbe2552078826af7a1f7\"}],\"scope_files\":[{\"bytes\":73,\"git_blob\":\"97d8569986750f071d006023b656b2651b263c73\",\"kind\":\"snapshot\",\"path\":\"formal/GLOSSARY.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"554783837178438d8c9cac728e8be4ba8edabadfc64e736227ae9e0e8f9293bd\"},{\"bytes\":92,\"git_blob\":\"cda22816532dfb264a8739cffc16b6d41cbbbf5e\",\"kind\":\"snapshot\",\"path\":\"formal/SCOPE.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"765aa85be38b913b07548a56f21c600749ea727a96cbeb99d345ea30f317731b\"}]},\"target\":\"Demo.t\",\"type_content_bytes\":null,\"type_content_sha256\":null,\"unresolved_fields\":[\"type_content_bytes\",\"type_content_sha256\"]},{\"accepted_formal_proof_selector\":[],\"accepted_formal_statement_selector\":[],\"compiler_dependency_options_identity\":{\"build_config\":[{\"bytes\":85,\"git_blob\":\"c31b8ba6189dc0872704f4ea910f468502b3934d\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"24766498266ca3327ab43ce2551807099a474324ad4d1c9f5f2e0052c4e11afa\"},{\"bytes\":65,\"git_blob\":\"225d58dbcbb1116179103c8637c26e25310687f8\",\"kind\":\"snapshot\",\"path\":\"formal/lakefile.toml\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"66f41c071ca37d39d785a00d298ee2fb4f851b9d5a749d33928f97cbf405970b\"},{\"bytes\":25,\"git_blob\":\"ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5\",\"kind\":\"snapshot\",\"path\":\"formal/lean-toolchain\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"d5edba4e4b8faad9c1baeadb265716d20d03be4d1a2647dc5e35b0c0325bea7b\"}],\"compiler_identity\":{\"executable\":{\"bytes\":32,\"sha256\":\"f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00\"},\"version_output\":{\"bytes\":46,\"sha256\":\"09ae09205b0965c3841e1e334f268c5a6f7baf45eddad66cd0398d6fd9850e55\"}},\"dependencies\":[{\"name\":\"a_fixture\",\"revision\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"},{\"name\":\"z_fixture\",\"revision\":\"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"}],\"dependency_lock\":{\"bytes\":672,\"git_blob\":\"1dfc2ed4c155de7c1ca5dc2ca4171dccea3b1c5d\",\"kind\":\"snapshot\",\"path\":\"formal/lake-manifest.json\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"5ade86188a7c4f0ca0f4254318100cc7930d514375c4a256551c9254b84b2658\"},\"options\":[\"maxRecDepth=128\",\"autoImplicit=false\"],\"print_options\":[\"pp.explicit=true\",\"pp.universes=true\"],\"producer_sources\":[{\"bytes\":73,\"git_blob\":\"83fad939382bf3c996a5b707ca3f69f1fc25a02f\",\"kind\":\"snapshot\",\"path\":\"tools/formal_gate_check.py\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"698870017e3fde8a8c5743a2a6b2e9ff6a2a93cc78f0284546049794141542c4\"},{\"kind\":\"origin\",\"ref\":{\"bytes\":73,\"commit\":\"4444444444444444444444444444444444444444\",\"git_blob\":\"8eed3c0a0318245082c027b7a006cf5d853f5ddc\",\"path\":\"control/native-workflow.yml\",\"repository\":\"fixture/control\",\"sha256\":\"a768034663901091e4bd85420c43fd98ffabce3ce1f9ed17327a918e11fa45dd\"}},{\"kind\":\"origin\",\"ref\":{\"bytes\":56,\"commit\":\"4444444444444444444444444444444444444444\",\"git_blob\":\"cec033cc05bd392aa103ca10838d9db8c5cda786\",\"path\":\"control/supervisor.py\",\"repository\":\"fixture/control\",\"sha256\":\"ae4d3070f92e31d2f8c662eded4226e987630bf7a8e2cf307f5d40016b0106f1\"}}],\"runtime_identity\":{\"executables\":[{\"content\":{\"bytes\":32,\"sha256\":\"f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00\"},\"name\":\"lean\"},{\"content\":{\"bytes\":38,\"sha256\":\"b1a11ede32499568db933c8703d668015ef50342193338fd2e9fec59913e9be0\"},\"name\":\"python\"}],\"image_manifest\":null,\"platform\":\"synthetic-linux-amd64-nonimage\"},\"toolchain\":\"leanprover/lean4:v4.34.1\"},\"format\":\"main-formal-gate/v1\",\"manifest_contract_sha256\":\"ff592c9cbfc46b0376bb4ca7a33608e858ec9112352dad416bc4b793a1a583d9\",\"module_content_identity\":{\"bytes\":63,\"git_blob\":\"f1f9e1c25e8e491bd10d931cd6d0a64e78da034f\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Unlinked.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"31015cf8631441e3cb1554075e20247c7e31e8f4c16daabcec21ddc94557142e\"},\"native_repository\":\"fixture/collector-contract\",\"package\":{\"declared_name\":\"Fixture\",\"manifest_path\":\"formal/manifest.json\"},\"scope_content_identity\":{\"import_files\":[{\"bytes\":59,\"git_blob\":\"02e8e595beb0686b7cbc722923d2dd679552b2a0\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Base.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"dc90d249b1695b7048e28233959e8aa5511f9f93dc1984be5a0be0989ec99683\"},{\"bytes\":28,\"git_blob\":\"ec04f5b06cd1556280b6214bf6247dff75ab1a6f\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Extra.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"c8fe60595798b75c502b37d5e92b44a23a37a285a904cbe2552078826af7a1f7\"}],\"scope_files\":[{\"bytes\":73,\"git_blob\":\"97d8569986750f071d006023b656b2651b263c73\",\"kind\":\"snapshot\",\"path\":\"formal/GLOSSARY.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"554783837178438d8c9cac728e8be4ba8edabadfc64e736227ae9e0e8f9293bd\"},{\"bytes\":92,\"git_blob\":\"cda22816532dfb264a8739cffc16b6d41cbbbf5e\",\"kind\":\"snapshot\",\"path\":\"formal/SCOPE.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"765aa85be38b913b07548a56f21c600749ea727a96cbeb99d345ea30f317731b\"}]},\"target\":\"Demo.unlinked\",\"type_content_bytes\":null,\"type_content_sha256\":null,\"unresolved_fields\":[\"type_content_bytes\",\"type_content_sha256\"]}]}", + "sha256": "18d4c29be2f968bf6d527c5e900f96d11471c901437cf08e1b10d1f0885467ae" + }, + "print_options": { + "bytes": 10556, + "canonical_ascii_preimage": "{\"domain\":\"formal-regression-inventory/v1\",\"domain_id\":\"fixture-only-domain\",\"targets\":[{\"accepted_formal_proof_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":55,\"sha256\":\"f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98\",\"source\":{\"bytes\":56,\"git_blob\":\"1e604667139c6d43c69c0af76160c2374b5ef65c\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d\"},\"start_byte\":45}},{\"link_id\":\"z-fixture-link\",\"selector\":{\"end_byte\":55,\"sha256\":\"f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98\",\"source\":{\"bytes\":56,\"git_blob\":\"1e604667139c6d43c69c0af76160c2374b5ef65c\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d\"},\"start_byte\":45}}],\"accepted_formal_statement_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":41,\"sha256\":\"1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7\",\"source\":{\"bytes\":56,\"git_blob\":\"1e604667139c6d43c69c0af76160c2374b5ef65c\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d\"},\"start_byte\":20}},{\"link_id\":\"z-fixture-link\",\"selector\":{\"end_byte\":41,\"sha256\":\"1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7\",\"source\":{\"bytes\":56,\"git_blob\":\"1e604667139c6d43c69c0af76160c2374b5ef65c\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d\"},\"start_byte\":20}}],\"compiler_dependency_options_identity\":{\"build_config\":[{\"bytes\":85,\"git_blob\":\"c31b8ba6189dc0872704f4ea910f468502b3934d\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"24766498266ca3327ab43ce2551807099a474324ad4d1c9f5f2e0052c4e11afa\"},{\"bytes\":65,\"git_blob\":\"225d58dbcbb1116179103c8637c26e25310687f8\",\"kind\":\"snapshot\",\"path\":\"formal/lakefile.toml\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"66f41c071ca37d39d785a00d298ee2fb4f851b9d5a749d33928f97cbf405970b\"},{\"bytes\":25,\"git_blob\":\"ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5\",\"kind\":\"snapshot\",\"path\":\"formal/lean-toolchain\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"d5edba4e4b8faad9c1baeadb265716d20d03be4d1a2647dc5e35b0c0325bea7b\"}],\"compiler_identity\":{\"executable\":{\"bytes\":32,\"sha256\":\"f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00\"},\"version_output\":{\"bytes\":46,\"sha256\":\"09ae09205b0965c3841e1e334f268c5a6f7baf45eddad66cd0398d6fd9850e55\"}},\"dependencies\":[{\"name\":\"a_fixture\",\"revision\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"},{\"name\":\"z_fixture\",\"revision\":\"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"}],\"dependency_lock\":{\"bytes\":672,\"git_blob\":\"1dfc2ed4c155de7c1ca5dc2ca4171dccea3b1c5d\",\"kind\":\"snapshot\",\"path\":\"formal/lake-manifest.json\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"5ade86188a7c4f0ca0f4254318100cc7930d514375c4a256551c9254b84b2658\"},\"options\":[\"autoImplicit=false\",\"maxRecDepth=128\"],\"print_options\":[\"pp.universes=true\",\"pp.explicit=true\"],\"producer_sources\":[{\"bytes\":73,\"git_blob\":\"83fad939382bf3c996a5b707ca3f69f1fc25a02f\",\"kind\":\"snapshot\",\"path\":\"tools/formal_gate_check.py\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"698870017e3fde8a8c5743a2a6b2e9ff6a2a93cc78f0284546049794141542c4\"},{\"kind\":\"origin\",\"ref\":{\"bytes\":73,\"commit\":\"4444444444444444444444444444444444444444\",\"git_blob\":\"8eed3c0a0318245082c027b7a006cf5d853f5ddc\",\"path\":\"control/native-workflow.yml\",\"repository\":\"fixture/control\",\"sha256\":\"a768034663901091e4bd85420c43fd98ffabce3ce1f9ed17327a918e11fa45dd\"}},{\"kind\":\"origin\",\"ref\":{\"bytes\":56,\"commit\":\"4444444444444444444444444444444444444444\",\"git_blob\":\"cec033cc05bd392aa103ca10838d9db8c5cda786\",\"path\":\"control/supervisor.py\",\"repository\":\"fixture/control\",\"sha256\":\"ae4d3070f92e31d2f8c662eded4226e987630bf7a8e2cf307f5d40016b0106f1\"}}],\"runtime_identity\":{\"executables\":[{\"content\":{\"bytes\":32,\"sha256\":\"f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00\"},\"name\":\"lean\"},{\"content\":{\"bytes\":38,\"sha256\":\"b1a11ede32499568db933c8703d668015ef50342193338fd2e9fec59913e9be0\"},\"name\":\"python\"}],\"image_manifest\":null,\"platform\":\"synthetic-linux-amd64-nonimage\"},\"toolchain\":\"leanprover/lean4:v4.34.1\"},\"format\":\"main-formal-gate/v1\",\"manifest_contract_sha256\":\"ff592c9cbfc46b0376bb4ca7a33608e858ec9112352dad416bc4b793a1a583d9\",\"module_content_identity\":{\"bytes\":56,\"git_blob\":\"1e604667139c6d43c69c0af76160c2374b5ef65c\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d\"},\"native_repository\":\"fixture/collector-contract\",\"package\":{\"declared_name\":\"Fixture\",\"manifest_path\":\"formal/manifest.json\"},\"scope_content_identity\":{\"import_files\":[{\"bytes\":59,\"git_blob\":\"02e8e595beb0686b7cbc722923d2dd679552b2a0\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Base.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"dc90d249b1695b7048e28233959e8aa5511f9f93dc1984be5a0be0989ec99683\"},{\"bytes\":28,\"git_blob\":\"ec04f5b06cd1556280b6214bf6247dff75ab1a6f\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Extra.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"c8fe60595798b75c502b37d5e92b44a23a37a285a904cbe2552078826af7a1f7\"}],\"scope_files\":[{\"bytes\":73,\"git_blob\":\"97d8569986750f071d006023b656b2651b263c73\",\"kind\":\"snapshot\",\"path\":\"formal/GLOSSARY.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"554783837178438d8c9cac728e8be4ba8edabadfc64e736227ae9e0e8f9293bd\"},{\"bytes\":92,\"git_blob\":\"cda22816532dfb264a8739cffc16b6d41cbbbf5e\",\"kind\":\"snapshot\",\"path\":\"formal/SCOPE.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"765aa85be38b913b07548a56f21c600749ea727a96cbeb99d345ea30f317731b\"}]},\"target\":\"Demo.t\",\"type_content_bytes\":null,\"type_content_sha256\":null,\"unresolved_fields\":[\"type_content_bytes\",\"type_content_sha256\"]},{\"accepted_formal_proof_selector\":[],\"accepted_formal_statement_selector\":[],\"compiler_dependency_options_identity\":{\"build_config\":[{\"bytes\":85,\"git_blob\":\"c31b8ba6189dc0872704f4ea910f468502b3934d\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"24766498266ca3327ab43ce2551807099a474324ad4d1c9f5f2e0052c4e11afa\"},{\"bytes\":65,\"git_blob\":\"225d58dbcbb1116179103c8637c26e25310687f8\",\"kind\":\"snapshot\",\"path\":\"formal/lakefile.toml\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"66f41c071ca37d39d785a00d298ee2fb4f851b9d5a749d33928f97cbf405970b\"},{\"bytes\":25,\"git_blob\":\"ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5\",\"kind\":\"snapshot\",\"path\":\"formal/lean-toolchain\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"d5edba4e4b8faad9c1baeadb265716d20d03be4d1a2647dc5e35b0c0325bea7b\"}],\"compiler_identity\":{\"executable\":{\"bytes\":32,\"sha256\":\"f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00\"},\"version_output\":{\"bytes\":46,\"sha256\":\"09ae09205b0965c3841e1e334f268c5a6f7baf45eddad66cd0398d6fd9850e55\"}},\"dependencies\":[{\"name\":\"a_fixture\",\"revision\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"},{\"name\":\"z_fixture\",\"revision\":\"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"}],\"dependency_lock\":{\"bytes\":672,\"git_blob\":\"1dfc2ed4c155de7c1ca5dc2ca4171dccea3b1c5d\",\"kind\":\"snapshot\",\"path\":\"formal/lake-manifest.json\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"5ade86188a7c4f0ca0f4254318100cc7930d514375c4a256551c9254b84b2658\"},\"options\":[\"autoImplicit=false\",\"maxRecDepth=128\"],\"print_options\":[\"pp.universes=true\",\"pp.explicit=true\"],\"producer_sources\":[{\"bytes\":73,\"git_blob\":\"83fad939382bf3c996a5b707ca3f69f1fc25a02f\",\"kind\":\"snapshot\",\"path\":\"tools/formal_gate_check.py\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"698870017e3fde8a8c5743a2a6b2e9ff6a2a93cc78f0284546049794141542c4\"},{\"kind\":\"origin\",\"ref\":{\"bytes\":73,\"commit\":\"4444444444444444444444444444444444444444\",\"git_blob\":\"8eed3c0a0318245082c027b7a006cf5d853f5ddc\",\"path\":\"control/native-workflow.yml\",\"repository\":\"fixture/control\",\"sha256\":\"a768034663901091e4bd85420c43fd98ffabce3ce1f9ed17327a918e11fa45dd\"}},{\"kind\":\"origin\",\"ref\":{\"bytes\":56,\"commit\":\"4444444444444444444444444444444444444444\",\"git_blob\":\"cec033cc05bd392aa103ca10838d9db8c5cda786\",\"path\":\"control/supervisor.py\",\"repository\":\"fixture/control\",\"sha256\":\"ae4d3070f92e31d2f8c662eded4226e987630bf7a8e2cf307f5d40016b0106f1\"}}],\"runtime_identity\":{\"executables\":[{\"content\":{\"bytes\":32,\"sha256\":\"f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00\"},\"name\":\"lean\"},{\"content\":{\"bytes\":38,\"sha256\":\"b1a11ede32499568db933c8703d668015ef50342193338fd2e9fec59913e9be0\"},\"name\":\"python\"}],\"image_manifest\":null,\"platform\":\"synthetic-linux-amd64-nonimage\"},\"toolchain\":\"leanprover/lean4:v4.34.1\"},\"format\":\"main-formal-gate/v1\",\"manifest_contract_sha256\":\"ff592c9cbfc46b0376bb4ca7a33608e858ec9112352dad416bc4b793a1a583d9\",\"module_content_identity\":{\"bytes\":63,\"git_blob\":\"f1f9e1c25e8e491bd10d931cd6d0a64e78da034f\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Unlinked.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"31015cf8631441e3cb1554075e20247c7e31e8f4c16daabcec21ddc94557142e\"},\"native_repository\":\"fixture/collector-contract\",\"package\":{\"declared_name\":\"Fixture\",\"manifest_path\":\"formal/manifest.json\"},\"scope_content_identity\":{\"import_files\":[{\"bytes\":59,\"git_blob\":\"02e8e595beb0686b7cbc722923d2dd679552b2a0\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Base.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"dc90d249b1695b7048e28233959e8aa5511f9f93dc1984be5a0be0989ec99683\"},{\"bytes\":28,\"git_blob\":\"ec04f5b06cd1556280b6214bf6247dff75ab1a6f\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Extra.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"c8fe60595798b75c502b37d5e92b44a23a37a285a904cbe2552078826af7a1f7\"}],\"scope_files\":[{\"bytes\":73,\"git_blob\":\"97d8569986750f071d006023b656b2651b263c73\",\"kind\":\"snapshot\",\"path\":\"formal/GLOSSARY.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"554783837178438d8c9cac728e8be4ba8edabadfc64e736227ae9e0e8f9293bd\"},{\"bytes\":92,\"git_blob\":\"cda22816532dfb264a8739cffc16b6d41cbbbf5e\",\"kind\":\"snapshot\",\"path\":\"formal/SCOPE.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"765aa85be38b913b07548a56f21c600749ea727a96cbeb99d345ea30f317731b\"}]},\"target\":\"Demo.unlinked\",\"type_content_bytes\":null,\"type_content_sha256\":null,\"unresolved_fields\":[\"type_content_bytes\",\"type_content_sha256\"]}]}", + "sha256": "6638442cd458f54a4078cab9a54e5c51e3d48afc9e57b7aac1e7ec46cb804a3e" + } + }, + "records": [ + { + "availability": "UNRESOLVED_TYPE_RECORD", + "checked_local_copy_ref": { + "bytes": 75, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "1d2610908271710703c4d30ad9f9685eea55eebd", + "path": "formal/sources/fixture/NOTE.md", + "repository": "fixture/collector-contract", + "sha256": "cf2553aa0f294e046e50cfd5b10133819f2dff37117035f0269b1c33de408c58" + }, + "compiler_context": { + "compiler_identity": { + "executable": { + "bytes": 32, + "sha256": "f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00" + }, + "version_output": { + "bytes": 46, + "sha256": "09ae09205b0965c3841e1e334f268c5a6f7baf45eddad66cd0398d6fd9850e55" + } + }, + "dependency_lock_ref": { + "bytes": 672, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "1dfc2ed4c155de7c1ca5dc2ca4171dccea3b1c5d", + "path": "formal/lake-manifest.json", + "repository": "fixture/collector-contract", + "sha256": "5ade86188a7c4f0ca0f4254318100cc7930d514375c4a256551c9254b84b2658" + }, + "dependency_revisions": [ + { + "name": "a_fixture", + "revision": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + }, + { + "name": "z_fixture", + "revision": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" + } + ], + "options": [ + "autoImplicit=false", + "maxRecDepth=128" + ], + "producer_source_refs": [ + { + "bytes": 73, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "83fad939382bf3c996a5b707ca3f69f1fc25a02f", + "path": "tools/formal_gate_check.py", + "repository": "fixture/collector-contract", + "sha256": "698870017e3fde8a8c5743a2a6b2e9ff6a2a93cc78f0284546049794141542c4" + }, + { + "bytes": 56, + "commit": "4444444444444444444444444444444444444444", + "git_blob": "cec033cc05bd392aa103ca10838d9db8c5cda786", + "path": "control/supervisor.py", + "repository": "fixture/control", + "sha256": "ae4d3070f92e31d2f8c662eded4226e987630bf7a8e2cf307f5d40016b0106f1" + }, + { + "bytes": 73, + "commit": "4444444444444444444444444444444444444444", + "git_blob": "8eed3c0a0318245082c027b7a006cf5d853f5ddc", + "path": "control/native-workflow.yml", + "repository": "fixture/control", + "sha256": "a768034663901091e4bd85420c43fd98ffabce3ce1f9ed17327a918e11fa45dd" + } + ], + "runtime_identity": { + "executables": [ + { + "content": { + "bytes": 32, + "sha256": "f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00" + }, + "name": "lean" + }, + { + "content": { + "bytes": 38, + "sha256": "b1a11ede32499568db933c8703d668015ef50342193338fd2e9fec59913e9be0" + }, + "name": "python" + } + ], + "image_manifest": null, + "platform": "synthetic-linux-amd64-nonimage" + }, + "toolchain": "leanprover/lean4:v4.34.1" + }, + "declaration_slice": null, + "format": "main-formal-gate/v1", + "issues": [ + "SYNTHETIC_TEST_ONLY" + ], + "manifest_ref": { + "bytes": 3253, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "79003b67ab854170a94463568166ebb2f1d182f1", + "path": "formal/manifest.json", + "repository": "fixture/collector-contract", + "sha256": "ff592c9cbfc46b0376bb4ca7a33608e858ec9112352dad416bc4b793a1a583d9" + }, + "module_ref": { + "bytes": 56, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "1e604667139c6d43c69c0af76160c2374b5ef65c", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "69ee3b0f64b7493330866ea7eb4756fd69d0f7293c4e37b39065145e666af11d" + }, + "native_context": null, + "origin_ref": { + "bytes": 75, + "commit": "6666666666666666666666666666666666666666", + "git_blob": "1d2610908271710703c4d30ad9f9685eea55eebd", + "path": "notes/fixture.md", + "repository": "fixture/informal", + "sha256": "cf2553aa0f294e046e50cfd5b10133819f2dff37117035f0269b1c33de408c58" + }, + "proof_slice": null, + "scope_ref": { + "bytes": 92, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "cda22816532dfb264a8739cffc16b6d41cbbbf5e", + "path": "formal/SCOPE.md", + "repository": "fixture/collector-contract", + "sha256": "765aa85be38b913b07548a56f21c600749ea727a96cbeb99d345ea30f317731b" + }, + "target": "Demo.t", + "type_record": null + }, + { + "availability": "UNRESOLVED_TYPE_RECORD", + "checked_local_copy_ref": { + "bytes": 75, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "1d2610908271710703c4d30ad9f9685eea55eebd", + "path": "formal/sources/fixture/NOTE.md", + "repository": "fixture/collector-contract", + "sha256": "cf2553aa0f294e046e50cfd5b10133819f2dff37117035f0269b1c33de408c58" + }, + "compiler_context": { + "compiler_identity": { + "executable": { + "bytes": 32, + "sha256": "f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00" + }, + "version_output": { + "bytes": 46, + "sha256": "09ae09205b0965c3841e1e334f268c5a6f7baf45eddad66cd0398d6fd9850e55" + } + }, + "dependency_lock_ref": { + "bytes": 672, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "1dfc2ed4c155de7c1ca5dc2ca4171dccea3b1c5d", + "path": "formal/lake-manifest.json", + "repository": "fixture/collector-contract", + "sha256": "5ade86188a7c4f0ca0f4254318100cc7930d514375c4a256551c9254b84b2658" + }, + "dependency_revisions": [ + { + "name": "a_fixture", + "revision": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + }, + { + "name": "z_fixture", + "revision": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" + } + ], + "options": [ + "autoImplicit=false", + "maxRecDepth=128" + ], + "producer_source_refs": [ + { + "bytes": 73, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "83fad939382bf3c996a5b707ca3f69f1fc25a02f", + "path": "tools/formal_gate_check.py", + "repository": "fixture/collector-contract", + "sha256": "698870017e3fde8a8c5743a2a6b2e9ff6a2a93cc78f0284546049794141542c4" + }, + { + "bytes": 56, + "commit": "4444444444444444444444444444444444444444", + "git_blob": "cec033cc05bd392aa103ca10838d9db8c5cda786", + "path": "control/supervisor.py", + "repository": "fixture/control", + "sha256": "ae4d3070f92e31d2f8c662eded4226e987630bf7a8e2cf307f5d40016b0106f1" + }, + { + "bytes": 73, + "commit": "4444444444444444444444444444444444444444", + "git_blob": "8eed3c0a0318245082c027b7a006cf5d853f5ddc", + "path": "control/native-workflow.yml", + "repository": "fixture/control", + "sha256": "a768034663901091e4bd85420c43fd98ffabce3ce1f9ed17327a918e11fa45dd" + } + ], + "runtime_identity": { + "executables": [ + { + "content": { + "bytes": 32, + "sha256": "f3e6186bdca706546273cd778d5585186f5f481e5a6f66ca8fa86f391c286b00" + }, + "name": "lean" + }, + { + "content": { + "bytes": 38, + "sha256": "b1a11ede32499568db933c8703d668015ef50342193338fd2e9fec59913e9be0" + }, + "name": "python" + } + ], + "image_manifest": null, + "platform": "synthetic-linux-amd64-nonimage" + }, + "toolchain": "leanprover/lean4:v4.34.1" + }, + "declaration_slice": null, + "format": "main-formal-gate/v1", + "issues": [ + "SYNTHETIC_TEST_ONLY" + ], + "manifest_ref": { + "bytes": 3253, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "79003b67ab854170a94463568166ebb2f1d182f1", + "path": "formal/manifest.json", + "repository": "fixture/collector-contract", + "sha256": "ff592c9cbfc46b0376bb4ca7a33608e858ec9112352dad416bc4b793a1a583d9" + }, + "module_ref": { + "bytes": 63, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "f1f9e1c25e8e491bd10d931cd6d0a64e78da034f", + "path": "formal/Fixture/Unlinked.lean", + "repository": "fixture/collector-contract", + "sha256": "31015cf8631441e3cb1554075e20247c7e31e8f4c16daabcec21ddc94557142e" + }, + "native_context": null, + "origin_ref": { + "bytes": 75, + "commit": "6666666666666666666666666666666666666666", + "git_blob": "1d2610908271710703c4d30ad9f9685eea55eebd", + "path": "notes/fixture.md", + "repository": "fixture/informal", + "sha256": "cf2553aa0f294e046e50cfd5b10133819f2dff37117035f0269b1c33de408c58" + }, + "proof_slice": null, + "scope_ref": { + "bytes": 92, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "cda22816532dfb264a8739cffc16b6d41cbbbf5e", + "path": "formal/SCOPE.md", + "repository": "fixture/collector-contract", + "sha256": "765aa85be38b913b07548a56f21c600749ea727a96cbeb99d345ea30f317731b" + }, + "target": "Demo.unlinked", + "type_record": null + } + ], + "request": { + "base": { + "commit": "1111111111111111111111111111111111111111", + "repository": "fixture/collector-contract", + "tree": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + }, + "base_ref": "main", + "checked_merge": { + "commit": "3333333333333333333333333333333333333333", + "repository": "fixture/collector-contract", + "tree": "cccccccccccccccccccccccccccccccccccccccc" + }, + "checked_merge_parents": [ + "1111111111111111111111111111111111111111", + "2222222222222222222222222222222222222222" + ], + "control": { + "commit": "4444444444444444444444444444444444444444", + "repository": "fixture/control", + "tree": "dddddddddddddddddddddddddddddddddddddddd" + }, + "head": { + "commit": "2222222222222222222222222222222222222222", + "repository": "fixture/collector-contract", + "tree": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" + }, + "head_ref": "fixture-head", + "merge_mode": "service_merge", + "policy_sha256": "f6f115506e2b0b7600dbd68cd394b5e0d6de56f8fa105eac87a9fda5de2f4e58", + "pull_request": "17", + "repository": "fixture/collector-contract", + "schema_version": 1 + }, + "status": "CONCRETE_PROPOSED_PROFILE_FOR_FRESH_WHOLE_REVIEW_NOT_ADMITTED", + "wire_contract": { + "aggregation": "issues are exact sorted unique reason strings, aggregated across all independently valid branches and all target rows. TYPE_RECORD_UNAVAILABLE and SYNTHETIC_AUTHORITY_UNQUALIFIED do not short-circuit other failures. Invalid branch shape records WIRE_PROFILE_INVALID and does not traverse ill-typed descendants; independent branches are still checked. Duplicate identity refuses before canonical sorting. Reason strings never enter core.", + "decoder": { + "container_depth_max_inclusive": 64, + "depth": "Root object/list depth=1; scalar root depth=0. Check structural depth before schema validation; 65 nested containers is depth error.", + "encoding": "strict UTF-8, no BOM", + "errors": "ValueError; lexical category wins before shape refusal. Duplicate including nested => duplicate; nonfinite tokens/overflow => finite; >limit => size/limit/large; depth>64 => depth; trailing JSON => trailing/extra data. No AssertionError-based validation.", + "json_bytes_max_inclusive": 16777216, + "policy_pin": "expected_sha256 exact lower64hex equals SHA256 of exact raw bytes before semantic acceptance; whitespace retained in raw pin; strict lexical malformed input still refuses.", + "raw_type": "exact bytes only; no bytearray/str" + }, + "id": "formal-regression-synthetic-input-profile/r01", + "joins": [ + "membership.side base resolves exactly request.base B; candidate resolves exactly request.checked_merge S. membership.snapshot equals the whole corresponding CommitRef. All non-origin Source refs match snapshot repository/commit; native mode=100644 and all six GitRef fields join their retained raw bytes/SHA/framed Git blob. Origin refs retain all six immutable fields and may not be relabelled snapshot.", + "Every role_input and target_input GitRef equals a retained source full GitRef, including commit. Record manifest/module/scope/origin/checked-copy/lock/producer refs equal full retained refs. Repeated repository/path references agree. Snapshot projection alone drops commit; original refs remain complete.", + "Decode raw native_manifest; derive package from package string plus manifest path; target names from all object targets, including zero-link/unlinked target. native_targets and records exhaust that set exactly once. target.module resolves package_root/module and belongs to native source_modules. Raw root module imports preserve source_modules order.", + "Every raw native files entry joins candidate source bytes/SHA; complete fixture candidate source set equals files plus all unbound_files, including exact manifest and unbound ALIGNMENT.md. Every native origin resolves retained origin, equal checked local copy and verbatim informal anchor. Main origin/local-copy fields remain native seven-field form; full GitRefs are separate.", + "Raw toolchain equals manifest/producer/records toolchain. Raw lock packages name/rev set equals native dependency_revisions object, membership.native_dependencies, producer observation, policy dependency revision set and every compiler_context dependency_revisions. No shortened revision or duplicate name.", + "NativeProducerPolicy workflow+supervisor_source_refs equals complete producer source set; source_control_files equals full held build/producer/scope/import/target enumerations. Native bound minimum build/files, root/source module and scope inputs are not guessed from changed files.", + "Parse raw producer_observation and require equality with membership.producer_observation; all compiler executable/version/runtime named refs resolve raw sources and byte identities. options/print_options match producer observation and every context/policy/effective membership value in exact order; runtime null image only under non-image kind.", + "Resolve each target import closure from literal native Lean import lines to registered package modules; compare complete direct/transitive imported refs excluding own module against target_inputs and global import union. No empty guessed import set.", + "Acceptance links enumerate exact synthetic known link IDs. Both selector arrays per target have identical IDs, with source content equal the resolved target module, exact bounds and raw slice SHA. Known zero links yields both empty arrays. Missing links/qualification is unknown and never an empty accepted set." + ], + "ordering": { + "projection": "Sort only declared unordered content arrays into accepted canonical target/dependency/source-role/runtime/selector order, after uniqueness and full joins. Preserve ordered option/print-option strings byte-for-byte. Canonical inventory_sha256 boundary refuses unsorted core arrays; it does not silently sort them.", + "raw_ordered": [ + "raw_native_manifest.source_modules", + "raw_native_manifest.targets", + "producer_observation.options", + "producer_observation.print_options", + "compiler_context.options", + "membership.print_options", + "NativeProducerPolicy.print_options" + ], + "raw_unordered": [ + "records", + "membership.native_targets", + "membership.sources", + "membership.native_dependencies", + "membership.role_inputs.*", + "membership.target_inputs", + "membership.target_inputs[].imports", + "compiler_context.dependency_revisions", + "compiler_context.producer_source_refs", + "runtime_identity.executables", + "producer_observation.dependencies", + "producer_observation.runtime_executable_refs", + "acceptances.links" + ] + }, + "primitive_rules": { + "base64": "exact canonical standard base64 with strict validation and encode(decode(value)) equality", + "enum": "both exact Python/JSON scalar type and value must match one member; true never equals 1", + "hex40": "exact lowercase ASCII [0-9a-f]{40}", + "name": "ASCII [A-Za-z_][A-Za-z0-9_.']*", + "nonempty": "exact nonempty str", + "null": "exact null", + "path": "exact nonempty relative normalized POSIX repository path; no empty/dot/dotdot segments, leading slash, backslash, URL, NUL or control characters", + "positive_int": "type(value) is int and value>0; bool excluded", + "repository": "ASCII owner/repo, each component nonempty, no URL or slash beyond separator", + "sha256": "exact lowercase ASCII [0-9a-f]{64}", + "string": "exact str including empty", + "uint": "type(value) is int and value>=0; bool excluded" + }, + "qualification_rules": [ + "Synthetic non-type fields are structurally projected only after complete raw/source/role/native/producer/selector joins. Their presence is never native qualification. Both type fields are null and are the only unresolved_fields in the held baseline.", + "This boundary accepts only SYNTHETIC_STRUCTURE_ONLY plus explicit UNQUALIFIED values. Native_context/type_record remain null. A native_qualified/authenticated/accepted flag, changed qualifier or unknown acceptance is refused; changing a label cannot select a production authority path.", + "Every content_inventory result in this synthetic boundary has formal_inventory_sha256=null, including fully materialized structural inputs. Diagnostic SHA is precisely the accepted canonical core formula. SYNTHETIC_AUTHORITY_UNQUALIFIED remains an issue outside core.", + "Actual M1/M2, native service membership, type original and accepted mapping/review authority are absent. Production needs separately authenticated native inputs and reviewed profile; it cannot earn authority from this fixture schema or booleans." + ], + "reason_actions": { + "DEPENDENCY_SET_MISMATCH": "Keep identity-complete core only with compiler_dependency_options_identity null and exact unresolved field.", + "DUPLICATE_TARGET_IDENTITY": "Repeated native identity, even identical; no core/digests.", + "IMPORT_SET_MISMATCH": "Raw import closure and complete per-target import inputs disagree: scope_content_identity null/listed.", + "NATIVE_ENUMERATION_UNRESOLVED": "Missing/unknown/ambiguous native_targets/enumeration; no core/digests.", + "NATIVE_FORMAT_UNSUPPORTED": "Unsupported format; no core/digests.", + "NATIVE_MANIFEST_PROJECTION_MISMATCH": "Raw package/module/files/source/manifest cached projection disagrees; no core/digests.", + "NATIVE_TARGET_SET_MISMATCH": "Raw manifest/native_targets/records/target_inputs disagree; no core/digests.", + "PRODUCER_CONTEXT_MISMATCH": "Raw producer observation/options/print/runtime/source context disagree: compiler_dependency_options_identity null/listed.", + "RUNTIME_IDENTITY_UNRESOLVED": "Image/null/executable runtime mismatch: compiler_dependency_options_identity null/listed.", + "SELECTOR_ACCEPTANCE_UNRESOLVED": "Missing/unknown links or qualifier: both accepted_formal_*_selector fields null/listed, never empty guess.", + "SELECTOR_BYTES_MISMATCH": "Bad selector source/bounds/slice SHA: affected selector field null/listed.", + "SELECTOR_LINK_SET_MISMATCH": "Foreign/duplicate/inconsistent accepted link ID or target: both selector fields null/listed.", + "SOURCE_BYTES_MISMATCH": "Bad raw length/SHA/Git blob: affected content field null/listed; if manifest affected, no core/digests.", + "SOURCE_MEMBERSHIP_MISMATCH": "Wrong full snapshot/ref join: affected module/compiler/scope/selector field null/listed; if manifest or native snapshot identity affected, no core/digests.", + "SOURCE_ROLE_ENUMERATION_UNRESOLVED": "Missing/unknown/omitted complete role input: scope/import affects scope_content_identity; build/producer affects compiler_dependency_options_identity; each affected field null/listed.", + "SOURCE_ROLE_MISMATCH": "Origin/snapshot role relabel: affected module/compiler/scope/selector field null/listed; if manifest affected, no core/digests.", + "SYNTHETIC_AUTHORITY_UNQUALIFIED": "Always present in this synthetic boundary; formal digest null; no added unresolved field because all such values are structural-only, not native admission.", + "SYNTHETIC_NATIVE_EVIDENCE_REFUSED": "Synthetic-only boundary received nonnull native_context/type_record or native qualification: no core/digests.", + "TYPE_RECORD_UNAVAILABLE": "type_content_bytes/type_content_sha256 null on every record without qualified type; list both field names.", + "WIRE_PROFILE_INVALID": "Closed/type malformed input; no accepted core/digests. A more specific missing enum/role/acceptance reason below takes precedence for that location." + }, + "roots": { + "acceptances": "Acceptances", + "diagnostic_policy": "DiagnosticPolicy", + "membership": "Membership", + "raw_dependency_lock": "LakeLock", + "raw_native_manifest": "NativeManifest", + "raw_producer_observation": "ProducerObservation", + "records[]": "TargetStatement" + }, + "scope": "Concrete proposed internal fixture wire types. DiagnosticPolicy is a strict subprofile of accepted Policy. No production authentication/admission interface is implemented or supplied.", + "shape_rules": [ + "All object fields mandatory, exact and closed recursively. No defaulting/coercion/unknown-field ignore.", + "Arrays exact lists; min/max inclusive. unique_by=[] means unique canonical whole values; named paths mean unique canonical tuple of named field values. Unordered means input order is insignificant; it does not permit duplicates.", + "Union has exactly one valid branch. Nullable permits null or exactly its named item. Maps have only keys satisfying key primitive and values satisfying named type.", + "NativeManifest is the retained supported Main structural subset, with unchanged six-field object targets, seven-field origins, native package string, dependency object and ordered source_modules/targets. It supplies no extra native qualification fields." + ], + "types": { + "AcceptanceLink": { + "closed": true, + "fields": { + "formal_proof_selector": { + "item": "Selector", + "kind": "nullable" + }, + "formal_statement_selector": { + "item": "Selector", + "kind": "nullable" + }, + "link_id": "nonempty", + "target": "name" + }, + "kind": "object" + }, + "Acceptances": { + "closed": true, + "fields": { + "domain_id": "nonempty", + "links": { + "item": "AcceptanceLink", + "kind": "array", + "min": 0, + "order": "unordered", + "unique_by": [ + "link_id" + ] + }, + "qualification": { + "kind": "enum", + "values": [ + "SYNTHETIC_ONLY_NOT_NATIVE_ACCEPTANCE" + ] + }, + "schema_version": { + "kind": "enum", + "values": [ + 1 + ] + } + }, + "kind": "object" + }, + "ArtifactInventoryContract": { + "closed": true, + "fields": { + "mode": { + "kind": "enum", + "values": [ + "SYNTHETIC_STRUCTURAL_INPUT_ONLY" + ] + }, + "native_originals": { + "kind": "enum", + "values": [ + "UNQUALIFIED" + ] + } + }, + "kind": "object" + }, + "AttemptCustodyContract": { + "closed": true, + "fields": { + "mode": { + "kind": "enum", + "values": [ + "UNQUALIFIED" + ] + }, + "native_context": "null" + }, + "kind": "object" + }, + "ByteContent": { + "closed": true, + "fields": { + "bytes": "uint", + "sha256": "sha256" + }, + "kind": "object" + }, + "CommitRef": { + "closed": true, + "fields": { + "commit": "hex40", + "repository": "repository", + "tree": "hex40" + }, + "kind": "object" + }, + "CompilerContext": { + "closed": true, + "fields": { + "compiler_identity": "CompilerIdentity", + "dependency_lock_ref": "GitRef", + "dependency_revisions": { + "item": "Dependency", + "kind": "array", + "min": 0, + "order": "unordered", + "unique_by": [ + "name" + ] + }, + "options": { + "item": "string", + "kind": "array", + "min": 0, + "order": "ordered" + }, + "producer_source_refs": { + "item": "GitRef", + "kind": "array", + "min": 0, + "order": "unordered", + "unique_by": [ + "repository", + "path" + ] + }, + "runtime_identity": "RuntimeContent", + "toolchain": "nonempty" + }, + "kind": "object" + }, + "CompilerIdentity": { + "closed": true, + "fields": { + "executable": "ByteContent", + "version_output": "ByteContent" + }, + "kind": "object" + }, + "Dependency": { + "closed": true, + "fields": { + "name": "nonempty", + "revision": "hex40" + }, + "kind": "object" + }, + "DependencyPolicy": { + "closed": true, + "fields": { + "lock_ref": "GitRef", + "revisions": { + "item": "Dependency", + "kind": "array", + "min": 0, + "order": "unordered", + "unique_by": [ + "name" + ] + } + }, + "kind": "object" + }, + "DiagnosticPolicy": { + "closed": true, + "fields": { + "disclosure": "null", + "enforcement": "null", + "gate_sha256": { + "kind": "enum", + "values": [ + "a78f3e25f3b0cfe113e618a4c31a7a25d7f22af638c46dec1ecba221fa333ac8" + ] + }, + "graph_sources": { + "item": "GitRef", + "kind": "array", + "max": 0, + "min": 0, + "order": "unordered" + }, + "limits": "Limits", + "mapping_authorities": { + "item": "null", + "kind": "array", + "max": 0, + "min": 0, + "order": "unordered" + }, + "native_producer_policies": { + "item": "NativeProducerPolicy", + "kind": "array", + "max": 1, + "min": 1, + "order": "unordered", + "unique_by": [ + "format" + ] + }, + "preservation": "null", + "protected_domains": { + "item": "nonempty", + "kind": "array", + "min": 1, + "order": "unordered", + "unique_by": [] + }, + "publisher": "null", + "repositories": { + "item": "repository", + "kind": "array", + "min": 1, + "order": "unordered", + "unique_by": [] + }, + "review_authorities": { + "item": "null", + "kind": "array", + "max": 0, + "min": 0, + "order": "unordered" + }, + "schema_version": { + "kind": "enum", + "values": [ + 1 + ] + }, + "trusted_control_sources": { + "item": "GitRef", + "kind": "array", + "min": 0, + "order": "unordered", + "unique_by": [ + "repository", + "path" + ] + } + }, + "kind": "object" + }, + "GitRef": { + "closed": true, + "fields": { + "bytes": "uint", + "commit": "hex40", + "git_blob": "hex40", + "path": "path", + "repository": "repository", + "sha256": "sha256" + }, + "kind": "object" + }, + "LakeDependency": { + "closed": true, + "fields": { + "configFile": "path", + "inherited": { + "kind": "enum", + "values": [ + false + ] + }, + "inputRev": "hex40", + "manifestFile": "path", + "name": "nonempty", + "rev": "hex40", + "scope": "string", + "subDir": "null", + "type": { + "kind": "enum", + "values": [ + "git" + ] + }, + "url": "string" + }, + "kind": "object" + }, + "LakeLock": { + "closed": true, + "fields": { + "lakeDir": "path", + "name": "nonempty", + "packages": { + "item": "LakeDependency", + "kind": "array", + "min": 0, + "order": "unordered", + "unique_by": [ + "name" + ] + }, + "packagesDir": "path", + "version": { + "kind": "enum", + "values": [ + "1.1.0" + ] + } + }, + "kind": "object" + }, + "Limits": { + "closed": true, + "fields": { + "json_bytes": { + "kind": "enum", + "values": [ + 16777216 + ] + }, + "json_depth": { + "kind": "enum", + "values": [ + 64 + ] + } + }, + "kind": "object" + }, + "Membership": { + "closed": true, + "fields": { + "domain_id": "nonempty", + "enumeration": { + "kind": "enum", + "values": [ + "complete", + "unknown", + "ambiguous" + ] + }, + "native_dependencies": { + "item": "Dependency", + "kind": "array", + "min": 0, + "order": "unordered", + "unique_by": [ + "name" + ] + }, + "native_format": { + "kind": "enum", + "values": [ + "main-formal-gate/v1" + ] + }, + "native_repository": "repository", + "native_targets": { + "item": "name", + "kind": "array", + "min": 1, + "order": "unordered", + "unique_by": [] + }, + "package": "Package", + "print_options": { + "item": "string", + "kind": "array", + "min": 0, + "order": "ordered" + }, + "producer_observation": "ProducerObservation", + "producer_observation_ref": "GitRef", + "qualification": "Qualification", + "role_inputs": "RoleInputs", + "runtime_kind": { + "kind": "enum", + "values": [ + "non-image", + "image" + ] + }, + "schema_version": { + "kind": "enum", + "values": [ + 1 + ] + }, + "side": { + "kind": "enum", + "values": [ + "base", + "candidate" + ] + }, + "snapshot": "CommitRef", + "sources": { + "item": "Source", + "kind": "array", + "min": 1, + "order": "unordered", + "unique_by": [ + "ref.repository", + "ref.path" + ] + }, + "target_inputs": { + "item": "TargetInputs", + "kind": "array", + "min": 1, + "order": "unordered", + "unique_by": [ + "target" + ] + } + }, + "kind": "object" + }, + "NamedExecutableContent": { + "closed": true, + "fields": { + "content": "ByteContent", + "name": "nonempty" + }, + "kind": "object" + }, + "NativeAuthor": { + "closed": true, + "fields": { + "agent": "nonempty", + "family": "nonempty", + "provider": "nonempty" + }, + "kind": "object" + }, + "NativeCoordination": { + "closed": true, + "fields": { + "guide": "path", + "math_pilot": "string", + "rollout_record": "path", + "work_item": "string", + "work_offer_addressed": "nonempty" + }, + "kind": "object" + }, + "NativeManifest": { + "closed": true, + "fields": { + "alignment_status": { + "kind": "enum", + "values": [ + "PENDING_INDEPENDENT_REVIEW" + ] + }, + "allowed_axioms": { + "item": "nonempty", + "kind": "array", + "min": 0, + "order": "ordered" + }, + "author": "NativeAuthor", + "coordination": "NativeCoordination", + "dependency_revisions": { + "key": "nonempty", + "kind": "map", + "value": "hex40" + }, + "files": { + "key": "path", + "kind": "map", + "value": "sha256" + }, + "formalization_status": { + "kind": "enum", + "values": [ + "proved" + ] + }, + "lean_toolchain": "nonempty", + "meaning": "nonempty", + "negative_controls": { + "key": "nonempty", + "kind": "map", + "value": "NativeNegative" + }, + "package": "nonempty", + "package_root": "path", + "root_module": "name", + "schema_version": { + "kind": "enum", + "values": [ + 1 + ] + }, + "scientific_effect": { + "kind": "enum", + "values": [ + "NONE" + ] + }, + "scientific_status_authority": { + "kind": "enum", + "values": [ + false + ] + }, + "source_modules": { + "item": "path", + "kind": "array", + "min": 1, + "order": "ordered", + "unique_by": [] + }, + "sources": { + "item": "NativeOrigin", + "kind": "array", + "min": 1, + "order": "unordered", + "unique_by": [ + "id" + ] + }, + "targets": { + "item": "NativeTarget", + "kind": "array", + "min": 1, + "order": "ordered", + "unique_by": [ + "name" + ] + }, + "unbound_files": { + "item": "path", + "kind": "array", + "min": 1, + "order": "unordered", + "unique_by": [] + } + }, + "kind": "object" + }, + "NativeNegative": { + "closed": true, + "fields": { + "module": "path", + "replace": "nonempty", + "with": "nonempty" + }, + "kind": "object" + }, + "NativeOrigin": { + "closed": true, + "fields": { + "bytes": "positive_int", + "commit": "hex40", + "id": "nonempty", + "local_copy": "path", + "path": "path", + "repository": "repository", + "sha256": "sha256" + }, + "kind": "object" + }, + "NativeProducerPolicy": { + "closed": true, + "fields": { + "artifact_inventory_contract": "ArtifactInventoryContract", + "attempt_custody_contract": "AttemptCustodyContract", + "dependency_policy": "DependencyPolicy", + "format": { + "kind": "enum", + "values": [ + "main-formal-gate/v1" + ] + }, + "print_options": { + "item": "string", + "kind": "array", + "min": 0, + "order": "ordered" + }, + "runtime_identity": "RuntimeContent", + "sandbox_contract": "SandboxContract", + "source_control_files": "SourceControlFiles", + "supervisor_source_refs": { + "item": "GitRef", + "kind": "array", + "min": 1, + "order": "unordered", + "unique_by": [ + "repository", + "path" + ] + }, + "toolchain": "nonempty", + "workflow_source_ref": "GitRef" + }, + "kind": "object" + }, + "NativeTarget": { + "closed": true, + "fields": { + "does_not_claim": "nonempty", + "informal_anchor": "nonempty", + "module": "path", + "name": "name", + "source": "nonempty", + "title": "nonempty" + }, + "kind": "object" + }, + "OriginContent": { + "closed": true, + "fields": { + "kind": { + "kind": "enum", + "values": [ + "origin" + ] + }, + "ref": "GitRef" + }, + "kind": "object" + }, + "Package": { + "closed": true, + "fields": { + "declared_name": "nonempty", + "manifest_path": "path" + }, + "kind": "object" + }, + "ProducerObservation": { + "closed": true, + "fields": { + "compiler_executable_ref": "GitRef", + "compiler_version_ref": "GitRef", + "dependencies": { + "item": "Dependency", + "kind": "array", + "min": 0, + "order": "unordered", + "unique_by": [ + "name" + ] + }, + "dependency_lock_ref": "GitRef", + "format": { + "kind": "enum", + "values": [ + "main-formal-gate/v1" + ] + }, + "options": { + "item": "string", + "kind": "array", + "min": 0, + "order": "ordered" + }, + "print_options": { + "item": "string", + "kind": "array", + "min": 0, + "order": "ordered" + }, + "runtime_executable_refs": { + "item": "RuntimeExecutableRef", + "kind": "array", + "min": 1, + "order": "unordered", + "unique_by": [ + "name" + ] + }, + "runtime_identity": "RuntimeContent", + "toolchain": "nonempty" + }, + "kind": "object" + }, + "Qualification": { + "closed": true, + "fields": { + "mapping": { + "kind": "enum", + "values": [ + "UNQUALIFIED" + ] + }, + "mode": { + "kind": "enum", + "values": [ + "SYNTHETIC_STRUCTURE_ONLY" + ] + }, + "native_execution": { + "kind": "enum", + "values": [ + "UNQUALIFIED" + ] + }, + "native_source": { + "kind": "enum", + "values": [ + "UNQUALIFIED" + ] + }, + "review": { + "kind": "enum", + "values": [ + "UNQUALIFIED" + ] + }, + "scientific_status_authority": { + "kind": "enum", + "values": [ + false + ] + } + }, + "kind": "object" + }, + "RoleInputs": { + "closed": true, + "fields": { + "build_config": { + "item": "GitRef", + "kind": "array", + "min": 0, + "order": "unordered", + "unique_by": [ + "repository", + "path" + ] + }, + "import_files": { + "item": "GitRef", + "kind": "array", + "min": 0, + "order": "unordered", + "unique_by": [ + "repository", + "path" + ] + }, + "producer_sources": { + "item": "GitRef", + "kind": "array", + "min": 0, + "order": "unordered", + "unique_by": [ + "repository", + "path" + ] + }, + "scope_files": { + "item": "GitRef", + "kind": "array", + "min": 1, + "order": "unordered", + "unique_by": [ + "repository", + "path" + ] + } + }, + "kind": "object" + }, + "RuntimeContent": { + "closed": true, + "fields": { + "executables": { + "item": "NamedExecutableContent", + "kind": "array", + "min": 1, + "order": "unordered", + "unique_by": [ + "name" + ] + }, + "image_manifest": { + "item": "ByteContent", + "kind": "nullable" + }, + "platform": "nonempty" + }, + "kind": "object" + }, + "RuntimeExecutableRef": { + "closed": true, + "fields": { + "name": "nonempty", + "ref": "GitRef" + }, + "kind": "object" + }, + "SandboxContract": { + "closed": true, + "fields": { + "authority": { + "kind": "enum", + "values": [ + "NONE" + ] + }, + "mode": { + "kind": "enum", + "values": [ + "NOT_RUN" + ] + } + }, + "kind": "object" + }, + "Selector": { + "closed": true, + "fields": { + "end_byte": "uint", + "sha256": "sha256", + "source": "SourceContent", + "start_byte": "uint" + }, + "kind": "object" + }, + "SnapshotContent": { + "closed": true, + "fields": { + "bytes": "uint", + "git_blob": "hex40", + "kind": { + "kind": "enum", + "values": [ + "snapshot" + ] + }, + "path": "path", + "repository": "repository", + "sha256": "sha256" + }, + "kind": "object" + }, + "Source": { + "closed": true, + "fields": { + "native_mode": { + "kind": "enum", + "values": [ + "100644" + ] + }, + "raw_base64": "base64", + "ref": "GitRef", + "role": { + "kind": "enum", + "values": [ + "formal_module", + "import_file", + "scope_file", + "package_document", + "unbound_document", + "build_config", + "dependency_lock", + "producer_source", + "package_test", + "informal_origin", + "checked_local_copy", + "compiler_binary", + "compiler_version_output", + "runtime_executable", + "native_manifest", + "producer_observation" + ] + }, + "side": { + "kind": "enum", + "values": [ + "base", + "candidate", + "origin" + ] + } + }, + "kind": "object" + }, + "SourceContent": { + "items": [ + "SnapshotContent", + "OriginContent" + ], + "kind": "union" + }, + "SourceControlFiles": { + "closed": true, + "fields": { + "build_config": { + "item": "GitRef", + "kind": "array", + "min": 0, + "order": "unordered", + "unique_by": [ + "repository", + "path" + ] + }, + "import_files": { + "item": "GitRef", + "kind": "array", + "min": 0, + "order": "unordered", + "unique_by": [ + "repository", + "path" + ] + }, + "producer_sources": { + "item": "GitRef", + "kind": "array", + "min": 0, + "order": "unordered", + "unique_by": [ + "repository", + "path" + ] + }, + "scope_files": { + "item": "GitRef", + "kind": "array", + "min": 1, + "order": "unordered", + "unique_by": [ + "repository", + "path" + ] + }, + "target_inputs": { + "item": "TargetInputs", + "kind": "array", + "min": 1, + "order": "unordered", + "unique_by": [ + "target" + ] + } + }, + "kind": "object" + }, + "TargetInputs": { + "closed": true, + "fields": { + "imports": { + "item": "GitRef", + "kind": "array", + "min": 0, + "order": "unordered", + "unique_by": [ + "repository", + "path" + ] + }, + "target": "name" + }, + "kind": "object" + }, + "TargetStatement": { + "closed": true, + "fields": { + "availability": { + "kind": "enum", + "values": [ + "UNRESOLVED_TYPE_RECORD" + ] + }, + "checked_local_copy_ref": { + "item": "GitRef", + "kind": "nullable" + }, + "compiler_context": "CompilerContext", + "declaration_slice": "null", + "format": { + "kind": "enum", + "values": [ + "main-formal-gate/v1" + ] + }, + "issues": { + "item": { + "kind": "enum", + "values": [ + "SYNTHETIC_TEST_ONLY" + ] + }, + "kind": "array", + "max": 1, + "min": 1, + "order": "unordered" + }, + "manifest_ref": "GitRef", + "module_ref": "GitRef", + "native_context": "null", + "origin_ref": { + "item": "GitRef", + "kind": "nullable" + }, + "proof_slice": "null", + "scope_ref": "GitRef", + "target": "name", + "type_record": "null" + }, + "kind": "object" + } + }, + "unknown_behavior": "No missing field is defaulted to empty/false/accepted. Unavailable required content is null with its exact field name in sorted unique unresolved_fields and diagnostic-only digest if identity enumeration remains complete. Unknown identity/native enumeration yields core/digests null. Untrusted/malformed wire cannot be an accepted diagnostic substitute. Known absence is explicit zero links or selector:null on a known link, never missing acceptance." + }, + "wire_negative_examples": [ + { + "id": "closed_AcceptanceLink", + "path": [ + "acceptances", + "links", + 0, + "unadmitted" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": "forged-extra" + }, + { + "id": "closed_Acceptances", + "path": [ + "acceptances", + "unadmitted" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": "forged-extra" + }, + { + "id": "closed_ByteContent", + "path": [ + "membership", + "producer_observation", + "runtime_identity", + "executables", + 0, + "content", + "unadmitted" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": "forged-extra" + }, + { + "id": "closed_CommitRef", + "path": [ + "membership", + "snapshot", + "unadmitted" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": "forged-extra" + }, + { + "id": "closed_CompilerContext", + "path": [ + "records", + 0, + "compiler_context", + "unadmitted" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": "forged-extra" + }, + { + "id": "closed_CompilerIdentity", + "path": [ + "records", + 0, + "compiler_context", + "compiler_identity", + "unadmitted" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": "forged-extra" + }, + { + "id": "closed_Dependency", + "path": [ + "membership", + "native_dependencies", + 0, + "unadmitted" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": "forged-extra" + }, + { + "id": "closed_GitRef", + "path": [ + "membership", + "role_inputs", + "build_config", + 0, + "unadmitted" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": "forged-extra" + }, + { + "id": "closed_Membership", + "path": [ + "membership", + "unadmitted" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": "forged-extra" + }, + { + "id": "closed_NamedExecutableContent", + "path": [ + "membership", + "producer_observation", + "runtime_identity", + "executables", + 0, + "unadmitted" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": "forged-extra" + }, + { + "id": "closed_Package", + "path": [ + "membership", + "package", + "unadmitted" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": "forged-extra" + }, + { + "id": "closed_ProducerObservation", + "path": [ + "membership", + "producer_observation", + "unadmitted" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": "forged-extra" + }, + { + "id": "closed_Qualification", + "path": [ + "membership", + "qualification", + "unadmitted" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": "forged-extra" + }, + { + "id": "closed_RoleInputs", + "path": [ + "membership", + "role_inputs", + "unadmitted" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": "forged-extra" + }, + { + "id": "closed_RuntimeContent", + "path": [ + "membership", + "producer_observation", + "runtime_identity", + "unadmitted" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": "forged-extra" + }, + { + "id": "closed_RuntimeExecutableRef", + "path": [ + "membership", + "producer_observation", + "runtime_executable_refs", + 0, + "unadmitted" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": "forged-extra" + }, + { + "id": "closed_Selector", + "path": [ + "acceptances", + "links", + 0, + "formal_statement_selector", + "unadmitted" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": "forged-extra" + }, + { + "id": "closed_SnapshotContent", + "path": [ + "acceptances", + "links", + 0, + "formal_statement_selector", + "source", + "unadmitted" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": "forged-extra" + }, + { + "id": "closed_Source", + "path": [ + "membership", + "sources", + 0, + "unadmitted" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": "forged-extra" + }, + { + "id": "closed_TargetInputs", + "path": [ + "membership", + "target_inputs", + 0, + "unadmitted" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": "forged-extra" + }, + { + "id": "closed_TargetStatement", + "path": [ + "records", + 0, + "unadmitted" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": "forged-extra" + }, + { + "id": "source_bytes_bool", + "path": [ + "membership", + "sources", + 0, + "ref", + "bytes" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": true + }, + { + "id": "membership_version_bool", + "path": [ + "membership", + "schema_version" + ], + "reason": "WIRE_PROFILE_INVALID", + "value": true + }, + { + "id": "unknown_source_qualifier", + "path": [ + "membership", + "qualification", + "native_source" + ], + "reason": "SYNTHETIC_NATIVE_EVIDENCE_REFUSED", + "value": "NATIVE" + }, + { + "id": "fabricated_native_context", + "path": [ + "records", + 0, + "native_context" + ], + "reason": "SYNTHETIC_NATIVE_EVIDENCE_REFUSED", + "value": {} + }, + { + "id": "fabricated_type_record", + "path": [ + "records", + 0, + "type_record" + ], + "reason": "SYNTHETIC_NATIVE_EVIDENCE_REFUSED", + "value": {} + }, + { + "id": "scope_role_wrong_commit", + "path": [ + "membership", + "role_inputs", + "scope_files", + 0, + "commit" + ], + "reason": "SOURCE_MEMBERSHIP_MISMATCH", + "value": "1111111111111111111111111111111111111111" + }, + { + "id": "cached_package_not_native", + "path": [ + "membership", + "package", + "declared_name" + ], + "reason": "NATIVE_MANIFEST_PROJECTION_MISMATCH", + "value": "ForgedPackage" + }, + { + "id": "cached_print_options_not_observed", + "path": [ + "membership", + "print_options" + ], + "reason": "PRODUCER_CONTEXT_MISMATCH", + "value": [ + "forged=1" + ] + }, + { + "id": "missing_import_closure_member", + "path": [ + "membership", + "target_inputs", + 0, + "imports" + ], + "reason": "IMPORT_SET_MISMATCH", + "value": [ + { + "bytes": 59, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "02e8e595beb0686b7cbc722923d2dd679552b2a0", + "path": "formal/Fixture/Base.lean", + "repository": "fixture/collector-contract", + "sha256": "dc90d249b1695b7048e28233959e8aa5511f9f93dc1984be5a0be0989ec99683" + } + ] + }, + { + "id": "missing_build_source", + "path": [ + "membership", + "role_inputs", + "build_config" + ], + "reason": "SOURCE_ROLE_ENUMERATION_UNRESOLVED", + "value": [ + { + "bytes": 25, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5", + "path": "formal/lean-toolchain", + "repository": "fixture/collector-contract", + "sha256": "d5edba4e4b8faad9c1baeadb265716d20d03be4d1a2647dc5e35b0c0325bea7b" + } + ] + }, + { + "id": "missing_fixed_producer_origin", + "path": [ + "membership", + "role_inputs", + "producer_sources" + ], + "reason": "SOURCE_ROLE_ENUMERATION_UNRESOLVED", + "value": [ + { + "bytes": 73, + "commit": "3333333333333333333333333333333333333333", + "git_blob": "83fad939382bf3c996a5b707ca3f69f1fc25a02f", + "path": "tools/formal_gate_check.py", + "repository": "fixture/collector-contract", + "sha256": "698870017e3fde8a8c5743a2a6b2e9ff6a2a93cc78f0284546049794141542c4" + } + ] + }, + { + "id": "unknown_selectors_not_known_zero", + "path": [ + "acceptances", + "qualification" + ], + "reason": "SELECTOR_ACCEPTANCE_UNRESOLVED", + "value": "UNKNOWN" + } + ] + }, + "test_ids": [ + "test_formal_regression.ContractControls.test_all_thirteen_target_fields_are_required", + "test_formal_regression.ContractControls.test_canonical_vector_0", + "test_formal_regression.ContractControls.test_canonical_vector_1", + "test_formal_regression.ContractControls.test_canonical_vector_2", + "test_formal_regression.ContractControls.test_canonical_vector_3", + "test_formal_regression.ContractControls.test_canonical_vector_4", + "test_formal_regression.ContractControls.test_canonical_vector_5", + "test_formal_regression.ContractControls.test_canonical_vector_6", + "test_formal_regression.ContractControls.test_canonical_vector_7", + "test_formal_regression.ContractControls.test_canonical_vector_8", + "test_formal_regression.ContractControls.test_collection_nonimage_null_does_not_admit_image_runtime", + "test_formal_regression.ContractControls.test_collection_refuses_ambiguous_enumeration", + "test_formal_regression.ContractControls.test_collection_refuses_duplicate_native_record", + "test_formal_regression.ContractControls.test_collection_refuses_foreign_native_target", + "test_formal_regression.ContractControls.test_collection_refuses_foreign_selector_link", + "test_formal_regression.ContractControls.test_collection_refuses_missing_enumeration", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_build_role", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_dependency", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_import_role", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_native_target", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_producer_role", + "test_formal_regression.ContractControls.test_collection_refuses_omitted_scope_role", + "test_formal_regression.ContractControls.test_collection_refuses_origin_relabelled_snapshot", + "test_formal_regression.ContractControls.test_collection_refuses_raw_source_digest_mismatch", + "test_formal_regression.ContractControls.test_collection_refuses_selector_raw_slice_mismatch", + "test_formal_regression.ContractControls.test_collection_refuses_snapshot_source_wrong_commit", + "test_formal_regression.ContractControls.test_collection_refuses_unknown_enumeration", + "test_formal_regression.ContractControls.test_collection_refuses_unknown_selector_acceptance", + "test_formal_regression.ContractControls.test_collection_refuses_unsupported_native_format", + "test_formal_regression.ContractControls.test_collection_unknown_enumeration_has_no_core", + "test_formal_regression.ContractControls.test_collection_zero_links_is_known_absence_diagnostic", + "test_formal_regression.ContractControls.test_compiler_binary_and_version_content_closed", + "test_formal_regression.ContractControls.test_compiler_dependency_content_closed", + "test_formal_regression.ContractControls.test_conflicting_duplicate_target_identity_refuses", + "test_formal_regression.ContractControls.test_dependency_and_runtime_arrays_require_canonical_order", + "test_formal_regression.ContractControls.test_dependency_names_unique_and_revisions_full", + "test_formal_regression.ContractControls.test_duplicate_identity_refuses", + "test_formal_regression.ContractControls.test_duplicate_source_role_paths_refuse", + "test_formal_regression.ContractControls.test_exact_integer_excludes_boolean", + "test_formal_regression.ContractControls.test_fixture_preimages_are_independent", + "test_formal_regression.ContractControls.test_import_set_excludes_target_module", + "test_formal_regression.ContractControls.test_inventory_baseline_hash", + "test_formal_regression.ContractControls.test_inventory_root_is_closed", + "test_formal_regression.ContractControls.test_inventory_root_types_and_domain", + "test_formal_regression.ContractControls.test_native_format_is_supported", + "test_formal_regression.ContractControls.test_native_identity_cannot_be_unresolved", + "test_formal_regression.ContractControls.test_negative_or_fractional_sizes_refuse", + "test_formal_regression.ContractControls.test_nested_compiler_runtime_and_selector_extra_fields_refuse", + "test_formal_regression.ContractControls.test_null_and_empty_selectors_are_distinct", + "test_formal_regression.ContractControls.test_options_remain_ordered_strings", + "test_formal_regression.ContractControls.test_origin_commit_remains_in_content_digest", + "test_formal_regression.ContractControls.test_origin_requires_all_six_full_ref_fields", + "test_formal_regression.ContractControls.test_package_identity_closed_and_safe", + "test_formal_regression.ContractControls.test_policy_boolean_version_refuses", + "test_formal_regression.ContractControls.test_policy_closed_field_set", + "test_formal_regression.ContractControls.test_policy_decode_uses_exact_raw_pin", + "test_formal_regression.ContractControls.test_policy_refuses_depth", + "test_formal_regression.ContractControls.test_policy_refuses_duplicate", + "test_formal_regression.ContractControls.test_policy_refuses_extra_field", + "test_formal_regression.ContractControls.test_policy_refuses_nonfinite", + "test_formal_regression.ContractControls.test_policy_refuses_oversize", + "test_formal_regression.ContractControls.test_policy_refuses_trailing", + "test_formal_regression.ContractControls.test_policy_whitespace_is_part_of_raw_pin", + "test_formal_regression.ContractControls.test_policy_wrong_raw_pin_refuses", + "test_formal_regression.ContractControls.test_print_options_order_changes_digest", + "test_formal_regression.ContractControls.test_recollection_keeps_content_digest", + "test_formal_regression.ContractControls.test_repeated_source_roles_cannot_disagree", + "test_formal_regression.ContractControls.test_request_commit_and_tree_are_full_lowercase_hashes", + "test_formal_regression.ContractControls.test_request_commit_refs_are_closed", + "test_formal_regression.ContractControls.test_request_decode_roundtrip", + "test_formal_regression.ContractControls.test_request_key_changes_each_source_identity", + "test_formal_regression.ContractControls.test_request_key_exact_domain_formula", + "test_formal_regression.ContractControls.test_request_key_refuses_acquisition_fields", + "test_formal_regression.ContractControls.test_request_refuses_bom", + "test_formal_regression.ContractControls.test_request_refuses_boolean_native_id", + "test_formal_regression.ContractControls.test_request_refuses_boolean_version", + "test_formal_regression.ContractControls.test_request_refuses_depth_over_64", + "test_formal_regression.ContractControls.test_request_refuses_duplicate_nested_key", + "test_formal_regression.ContractControls.test_request_refuses_duplicate_top_key", + "test_formal_regression.ContractControls.test_request_refuses_head_fallback", + "test_formal_regression.ContractControls.test_request_refuses_integer_native_id", + "test_formal_regression.ContractControls.test_request_refuses_invalid_utf8", + "test_formal_regression.ContractControls.test_request_refuses_missing_and_extra_fields", + "test_formal_regression.ContractControls.test_request_refuses_noncanonical_native_id", + "test_formal_regression.ContractControls.test_request_refuses_nonfinite_infinity", + "test_formal_regression.ContractControls.test_request_refuses_nonfinite_nan", + "test_formal_regression.ContractControls.test_request_refuses_nonfinite_negative_infinity", + "test_formal_regression.ContractControls.test_request_refuses_oversize", + "test_formal_regression.ContractControls.test_request_refuses_raw_bytearray", + "test_formal_regression.ContractControls.test_request_refuses_raw_str", + "test_formal_regression.ContractControls.test_request_refuses_supplied_url", + "test_formal_regression.ContractControls.test_request_refuses_trailing_value", + "test_formal_regression.ContractControls.test_request_refuses_uppercase_digest", + "test_formal_regression.ContractControls.test_request_refuses_wrong_merge_parents", + "test_formal_regression.ContractControls.test_request_refuses_wrong_root_type", + "test_formal_regression.ContractControls.test_required_null_needs_exact_unresolved_name", + "test_formal_regression.ContractControls.test_required_type_null_pair_cannot_be_half_known", + "test_formal_regression.ContractControls.test_runtime_executable_is_complete_nonempty_named_content", + "test_formal_regression.ContractControls.test_runtime_executable_names_unique", + "test_formal_regression.ContractControls.test_runtime_identity_closed", + "test_formal_regression.ContractControls.test_scope_and_import_role_values_are_arrays", + "test_formal_regression.ContractControls.test_scope_and_import_sets_closed", + "test_formal_regression.ContractControls.test_selector_bounds_are_exact", + "test_formal_regression.ContractControls.test_selector_entry_and_slice_closed", + "test_formal_regression.ContractControls.test_selector_link_sets_complete_and_unique", + "test_formal_regression.ContractControls.test_semantic_options_order_changes_digest", + "test_formal_regression.ContractControls.test_seven_content_deltas", + "test_formal_regression.ContractControls.test_snapshot_source_has_exact_six_content_fields", + "test_formal_regression.ContractControls.test_source_hashes_are_canonical", + "test_formal_regression.ContractControls.test_source_paths_refuse_escape_absolute_and_url", + "test_formal_regression.ContractControls.test_source_role_arrays_require_canonical_order", + "test_formal_regression.ContractControls.test_source_role_lists_have_unique_canonical_identity", + "test_formal_regression.ContractControls.test_target_array_requires_canonical_identity_order", + "test_formal_regression.ContractControls.test_target_unknown_field_refuses", + "test_formal_regression.ContractControls.test_unknown_required_type_is_diagnostic", + "test_formal_regression.ContractControls.test_unresolved_names_are_exact_sorted_unique" + ], + "test_module": "test_formal_regression" +} diff --git a/tests/fixtures/formal_regression/inventory-conformance.json b/tests/fixtures/formal_regression/inventory-conformance.json new file mode 100644 index 000000000..1c9e3286d --- /dev/null +++ b/tests/fixtures/formal_regression/inventory-conformance.json @@ -0,0 +1,1376 @@ +{ + "baseline_raw_inputs": [ + { + "bytes": 36, + "raw_base64": "dGhlb3JlbSBEZW1vLnQgOiBUcnVlIDo9IGJ5IHRyaXZpYWwK", + "role": "formal_module", + "sha256": "01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2" + }, + { + "bytes": 14, + "raw_base64": "RGVtby50IDogVHJ1ZQo=", + "role": "target_type_record", + "sha256": "41f2e67cfbe0ed463361466a589f2412c29e892507bee03d527fbd556d87c5ef" + }, + { + "bytes": 21, + "raw_base64": "Rml4dHVyZSBkb21haW4gb25seS4K", + "role": "scope_file", + "sha256": "f02d203cd02fe51dce38f860a48502322f39c852cc5668b1fa4454ac9c0a9a85" + }, + { + "bytes": 86, + "raw_base64": "eyJwYWNrYWdlcyI6W3sibmFtZSI6ImZpeHR1cmVfZGVwIiwicmV2IjoiYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYSJ9XX0=", + "role": "dependency_lock", + "sha256": "1ab9294e46112743a4489f401e0ba4dcd6d8e595458ede8b2a71958593774be4" + }, + { + "bytes": 146, + "raw_base64": "eyJmaWxlcyI6eyJmb3JtYWwvRml4dHVyZS9EZW1vLmxlYW4iOiIwMWMzNWEzM2M5OWI5NGY3OGYxZmFkZjVkZmMzZmMyZTI3NzkzZjE4MDE5NjU5NWUzNjExODQ3NzFkYTRjNWUyIn0sImZpeHR1cmVfb25seSI6dHJ1ZSwidGFyZ2V0cyI6WyJEZW1vLnQiXX0=", + "role": "native_manifest", + "sha256": "23431134396d8740104bbfd88ab2cadd0192f614422cb86a64fb7ab174973a33" + }, + { + "bytes": 23, + "raw_base64": "Zml4dHVyZSBjb21waWxlciBiaW5hcnk=", + "role": "compiler_binary", + "sha256": "4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3" + }, + { + "bytes": 27, + "raw_base64": "Zml4dHVyZSBjb21waWxlciB2ZXJzaW9uIDEK", + "role": "compiler_version_output", + "sha256": "02adc609bd41e61fbfaedd8c89919c9cc125e3cb9f806c4208f757e1819bd78f" + } + ], + "cases": [ + { + "canonical_ascii_preimage": "{\"domain\":\"formal-regression-inventory/v1\",\"domain_id\":\"fixture-only-domain\",\"targets\":[{\"accepted_formal_proof_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":35,\"sha256\":\"f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98\",\"source\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"start_byte\":25}}],\"accepted_formal_statement_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":21,\"sha256\":\"1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7\",\"source\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"start_byte\":0}}],\"compiler_dependency_options_identity\":{\"build_config\":[],\"compiler_identity\":{\"executable\":{\"bytes\":23,\"sha256\":\"4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3\"},\"version_output\":{\"bytes\":27,\"sha256\":\"02adc609bd41e61fbfaedd8c89919c9cc125e3cb9f806c4208f757e1819bd78f\"}},\"dependencies\":[{\"name\":\"fixture_dep\",\"revision\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}],\"dependency_lock\":{\"bytes\":86,\"git_blob\":\"61ec800f4939eb07f270dfb49e9082cb332ed2d1\",\"kind\":\"snapshot\",\"path\":\"formal/lake-manifest.json\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"1ab9294e46112743a4489f401e0ba4dcd6d8e595458ede8b2a71958593774be4\"},\"options\":[],\"print_options\":[\"pp.explicit=true\"],\"producer_sources\":[],\"runtime_identity\":{\"executables\":[{\"content\":{\"bytes\":23,\"sha256\":\"4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3\"},\"name\":\"compiler\"}],\"image_manifest\":null,\"platform\":\"synthetic-fixture-only\"},\"toolchain\":\"fixture-toolchain-1\"},\"format\":\"main-formal-gate/v1\",\"manifest_contract_sha256\":\"23431134396d8740104bbfd88ab2cadd0192f614422cb86a64fb7ab174973a33\",\"module_content_identity\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"native_repository\":\"fixture/collector-contract\",\"package\":{\"declared_name\":\"Fixture\",\"manifest_path\":\"formal/manifest.json\"},\"scope_content_identity\":{\"import_files\":[],\"scope_files\":[{\"bytes\":21,\"git_blob\":\"ad8dd765494201f2801c519e4968fd7d5e9f681b\",\"kind\":\"snapshot\",\"path\":\"formal/SCOPE.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"f02d203cd02fe51dce38f860a48502322f39c852cc5668b1fa4454ac9c0a9a85\"}]},\"target\":\"Demo.t\",\"type_content_bytes\":14,\"type_content_sha256\":\"41f2e67cfbe0ed463361466a589f2412c29e892507bee03d527fbd556d87c5ef\",\"unresolved_fields\":[]}]}", + "core": { + "domain": "formal-regression-inventory/v1", + "domain_id": "fixture-only-domain", + "targets": [ + { + "accepted_formal_proof_selector": [ + { + "link_id": "fixture-link", + "selector": { + "end_byte": 35, + "sha256": "f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98", + "source": { + "bytes": 36, + "git_blob": "561581e73cb27c7ab316ef290653e8d4d6df1280", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2" + }, + "start_byte": 25 + } + } + ], + "accepted_formal_statement_selector": [ + { + "link_id": "fixture-link", + "selector": { + "end_byte": 21, + "sha256": "1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7", + "source": { + "bytes": 36, + "git_blob": "561581e73cb27c7ab316ef290653e8d4d6df1280", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2" + }, + "start_byte": 0 + } + } + ], + "compiler_dependency_options_identity": { + "build_config": [], + "compiler_identity": { + "executable": { + "bytes": 23, + "sha256": "4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3" + }, + "version_output": { + "bytes": 27, + "sha256": "02adc609bd41e61fbfaedd8c89919c9cc125e3cb9f806c4208f757e1819bd78f" + } + }, + "dependencies": [ + { + "name": "fixture_dep", + "revision": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + } + ], + "dependency_lock": { + "bytes": 86, + "git_blob": "61ec800f4939eb07f270dfb49e9082cb332ed2d1", + "kind": "snapshot", + "path": "formal/lake-manifest.json", + "repository": "fixture/collector-contract", + "sha256": "1ab9294e46112743a4489f401e0ba4dcd6d8e595458ede8b2a71958593774be4" + }, + "options": [], + "print_options": [ + "pp.explicit=true" + ], + "producer_sources": [], + "runtime_identity": { + "executables": [ + { + "content": { + "bytes": 23, + "sha256": "4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3" + }, + "name": "compiler" + } + ], + "image_manifest": null, + "platform": "synthetic-fixture-only" + }, + "toolchain": "fixture-toolchain-1" + }, + "format": "main-formal-gate/v1", + "manifest_contract_sha256": "23431134396d8740104bbfd88ab2cadd0192f614422cb86a64fb7ab174973a33", + "module_content_identity": { + "bytes": 36, + "git_blob": "561581e73cb27c7ab316ef290653e8d4d6df1280", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2" + }, + "native_repository": "fixture/collector-contract", + "package": { + "declared_name": "Fixture", + "manifest_path": "formal/manifest.json" + }, + "scope_content_identity": { + "import_files": [], + "scope_files": [ + { + "bytes": 21, + "git_blob": "ad8dd765494201f2801c519e4968fd7d5e9f681b", + "kind": "snapshot", + "path": "formal/SCOPE.md", + "repository": "fixture/collector-contract", + "sha256": "f02d203cd02fe51dce38f860a48502322f39c852cc5668b1fa4454ac9c0a9a85" + } + ] + }, + "target": "Demo.t", + "type_content_bytes": 14, + "type_content_sha256": "41f2e67cfbe0ed463361466a589f2412c29e892507bee03d527fbd556d87c5ef", + "unresolved_fields": [] + } + ] + }, + "expected_classification": [ + "NO_CONTENT_DELTA" + ], + "id": "unchanged_content_first_acquisition", + "outside_hash_custody_example": { + "acquisition_id": "fixture-acquisition-1", + "artifact_id": "201", + "log_record_start_byte": 0, + "run_attempt": 1, + "run_id": "101" + }, + "qualification": "SYNTHETIC_UNQUALIFIED_LITERAL_ONLY", + "raw_input_changes": [], + "same_digest_as_baseline": true, + "sha256": "4a469c57ba103d8937795c709b59765a689ae24f92b6ee1d55ddc74037b849e6" + }, + { + "canonical_ascii_preimage": "{\"domain\":\"formal-regression-inventory/v1\",\"domain_id\":\"fixture-only-domain\",\"targets\":[{\"accepted_formal_proof_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":35,\"sha256\":\"f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98\",\"source\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"start_byte\":25}}],\"accepted_formal_statement_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":21,\"sha256\":\"1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7\",\"source\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"start_byte\":0}}],\"compiler_dependency_options_identity\":{\"build_config\":[],\"compiler_identity\":{\"executable\":{\"bytes\":23,\"sha256\":\"4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3\"},\"version_output\":{\"bytes\":27,\"sha256\":\"02adc609bd41e61fbfaedd8c89919c9cc125e3cb9f806c4208f757e1819bd78f\"}},\"dependencies\":[{\"name\":\"fixture_dep\",\"revision\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}],\"dependency_lock\":{\"bytes\":86,\"git_blob\":\"61ec800f4939eb07f270dfb49e9082cb332ed2d1\",\"kind\":\"snapshot\",\"path\":\"formal/lake-manifest.json\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"1ab9294e46112743a4489f401e0ba4dcd6d8e595458ede8b2a71958593774be4\"},\"options\":[],\"print_options\":[\"pp.explicit=true\"],\"producer_sources\":[],\"runtime_identity\":{\"executables\":[{\"content\":{\"bytes\":23,\"sha256\":\"4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3\"},\"name\":\"compiler\"}],\"image_manifest\":null,\"platform\":\"synthetic-fixture-only\"},\"toolchain\":\"fixture-toolchain-1\"},\"format\":\"main-formal-gate/v1\",\"manifest_contract_sha256\":\"23431134396d8740104bbfd88ab2cadd0192f614422cb86a64fb7ab174973a33\",\"module_content_identity\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"native_repository\":\"fixture/collector-contract\",\"package\":{\"declared_name\":\"Fixture\",\"manifest_path\":\"formal/manifest.json\"},\"scope_content_identity\":{\"import_files\":[],\"scope_files\":[{\"bytes\":21,\"git_blob\":\"ad8dd765494201f2801c519e4968fd7d5e9f681b\",\"kind\":\"snapshot\",\"path\":\"formal/SCOPE.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"f02d203cd02fe51dce38f860a48502322f39c852cc5668b1fa4454ac9c0a9a85\"}]},\"target\":\"Demo.t\",\"type_content_bytes\":14,\"type_content_sha256\":\"41f2e67cfbe0ed463361466a589f2412c29e892507bee03d527fbd556d87c5ef\",\"unresolved_fields\":[]}]}", + "core": { + "domain": "formal-regression-inventory/v1", + "domain_id": "fixture-only-domain", + "targets": [ + { + "accepted_formal_proof_selector": [ + { + "link_id": "fixture-link", + "selector": { + "end_byte": 35, + "sha256": "f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98", + "source": { + "bytes": 36, + "git_blob": "561581e73cb27c7ab316ef290653e8d4d6df1280", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2" + }, + "start_byte": 25 + } + } + ], + "accepted_formal_statement_selector": [ + { + "link_id": "fixture-link", + "selector": { + "end_byte": 21, + "sha256": "1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7", + "source": { + "bytes": 36, + "git_blob": "561581e73cb27c7ab316ef290653e8d4d6df1280", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2" + }, + "start_byte": 0 + } + } + ], + "compiler_dependency_options_identity": { + "build_config": [], + "compiler_identity": { + "executable": { + "bytes": 23, + "sha256": "4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3" + }, + "version_output": { + "bytes": 27, + "sha256": "02adc609bd41e61fbfaedd8c89919c9cc125e3cb9f806c4208f757e1819bd78f" + } + }, + "dependencies": [ + { + "name": "fixture_dep", + "revision": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + } + ], + "dependency_lock": { + "bytes": 86, + "git_blob": "61ec800f4939eb07f270dfb49e9082cb332ed2d1", + "kind": "snapshot", + "path": "formal/lake-manifest.json", + "repository": "fixture/collector-contract", + "sha256": "1ab9294e46112743a4489f401e0ba4dcd6d8e595458ede8b2a71958593774be4" + }, + "options": [], + "print_options": [ + "pp.explicit=true" + ], + "producer_sources": [], + "runtime_identity": { + "executables": [ + { + "content": { + "bytes": 23, + "sha256": "4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3" + }, + "name": "compiler" + } + ], + "image_manifest": null, + "platform": "synthetic-fixture-only" + }, + "toolchain": "fixture-toolchain-1" + }, + "format": "main-formal-gate/v1", + "manifest_contract_sha256": "23431134396d8740104bbfd88ab2cadd0192f614422cb86a64fb7ab174973a33", + "module_content_identity": { + "bytes": 36, + "git_blob": "561581e73cb27c7ab316ef290653e8d4d6df1280", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2" + }, + "native_repository": "fixture/collector-contract", + "package": { + "declared_name": "Fixture", + "manifest_path": "formal/manifest.json" + }, + "scope_content_identity": { + "import_files": [], + "scope_files": [ + { + "bytes": 21, + "git_blob": "ad8dd765494201f2801c519e4968fd7d5e9f681b", + "kind": "snapshot", + "path": "formal/SCOPE.md", + "repository": "fixture/collector-contract", + "sha256": "f02d203cd02fe51dce38f860a48502322f39c852cc5668b1fa4454ac9c0a9a85" + } + ] + }, + "target": "Demo.t", + "type_content_bytes": 14, + "type_content_sha256": "41f2e67cfbe0ed463361466a589f2412c29e892507bee03d527fbd556d87c5ef", + "unresolved_fields": [] + } + ] + }, + "expected_classification": [ + "NO_CONTENT_DELTA", + "NO_AUTOMATIC_NATIVE_REBIND" + ], + "id": "same_content_new_run_attempt_acquisition", + "outside_hash_custody_example": { + "acquisition_id": "fixture-acquisition-2", + "artifact_id": "202", + "log_record_start_byte": 91, + "run_attempt": 2, + "run_id": "102" + }, + "qualification": "SYNTHETIC_UNQUALIFIED_LITERAL_ONLY", + "raw_input_changes": [], + "same_digest_as_baseline": true, + "sha256": "4a469c57ba103d8937795c709b59765a689ae24f92b6ee1d55ddc74037b849e6" + }, + { + "canonical_ascii_preimage": "{\"domain\":\"formal-regression-inventory/v1\",\"domain_id\":\"fixture-only-domain\",\"targets\":[{\"accepted_formal_proof_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":35,\"sha256\":\"f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98\",\"source\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"start_byte\":25}}],\"accepted_formal_statement_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":21,\"sha256\":\"1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7\",\"source\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"start_byte\":0}}],\"compiler_dependency_options_identity\":{\"build_config\":[],\"compiler_identity\":{\"executable\":{\"bytes\":23,\"sha256\":\"4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3\"},\"version_output\":{\"bytes\":27,\"sha256\":\"02adc609bd41e61fbfaedd8c89919c9cc125e3cb9f806c4208f757e1819bd78f\"}},\"dependencies\":[{\"name\":\"fixture_dep\",\"revision\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}],\"dependency_lock\":{\"bytes\":86,\"git_blob\":\"61ec800f4939eb07f270dfb49e9082cb332ed2d1\",\"kind\":\"snapshot\",\"path\":\"formal/lake-manifest.json\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"1ab9294e46112743a4489f401e0ba4dcd6d8e595458ede8b2a71958593774be4\"},\"options\":[],\"print_options\":[\"pp.explicit=true\"],\"producer_sources\":[],\"runtime_identity\":{\"executables\":[{\"content\":{\"bytes\":23,\"sha256\":\"4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3\"},\"name\":\"compiler\"}],\"image_manifest\":null,\"platform\":\"synthetic-fixture-only\"},\"toolchain\":\"fixture-toolchain-1\"},\"format\":\"main-formal-gate/v1\",\"manifest_contract_sha256\":\"23431134396d8740104bbfd88ab2cadd0192f614422cb86a64fb7ab174973a33\",\"module_content_identity\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"native_repository\":\"fixture/collector-contract\",\"package\":{\"declared_name\":\"Fixture\",\"manifest_path\":\"formal/manifest.json\"},\"scope_content_identity\":{\"import_files\":[],\"scope_files\":[{\"bytes\":21,\"git_blob\":\"ad8dd765494201f2801c519e4968fd7d5e9f681b\",\"kind\":\"snapshot\",\"path\":\"formal/SCOPE.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"f02d203cd02fe51dce38f860a48502322f39c852cc5668b1fa4454ac9c0a9a85\"}]},\"target\":\"Demo.t\",\"type_content_bytes\":15,\"type_content_sha256\":\"1cdf12659a464ffcd9691c1f56dac178e5a01a2ddc80e18afcf5e2e5ee9b639e\",\"unresolved_fields\":[]}]}", + "core": { + "domain": "formal-regression-inventory/v1", + "domain_id": "fixture-only-domain", + "targets": [ + { + "accepted_formal_proof_selector": [ + { + "link_id": "fixture-link", + "selector": { + "end_byte": 35, + "sha256": "f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98", + "source": { + "bytes": 36, + "git_blob": "561581e73cb27c7ab316ef290653e8d4d6df1280", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2" + }, + "start_byte": 25 + } + } + ], + "accepted_formal_statement_selector": [ + { + "link_id": "fixture-link", + "selector": { + "end_byte": 21, + "sha256": "1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7", + "source": { + "bytes": 36, + "git_blob": "561581e73cb27c7ab316ef290653e8d4d6df1280", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2" + }, + "start_byte": 0 + } + } + ], + "compiler_dependency_options_identity": { + "build_config": [], + "compiler_identity": { + "executable": { + "bytes": 23, + "sha256": "4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3" + }, + "version_output": { + "bytes": 27, + "sha256": "02adc609bd41e61fbfaedd8c89919c9cc125e3cb9f806c4208f757e1819bd78f" + } + }, + "dependencies": [ + { + "name": "fixture_dep", + "revision": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + } + ], + "dependency_lock": { + "bytes": 86, + "git_blob": "61ec800f4939eb07f270dfb49e9082cb332ed2d1", + "kind": "snapshot", + "path": "formal/lake-manifest.json", + "repository": "fixture/collector-contract", + "sha256": "1ab9294e46112743a4489f401e0ba4dcd6d8e595458ede8b2a71958593774be4" + }, + "options": [], + "print_options": [ + "pp.explicit=true" + ], + "producer_sources": [], + "runtime_identity": { + "executables": [ + { + "content": { + "bytes": 23, + "sha256": "4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3" + }, + "name": "compiler" + } + ], + "image_manifest": null, + "platform": "synthetic-fixture-only" + }, + "toolchain": "fixture-toolchain-1" + }, + "format": "main-formal-gate/v1", + "manifest_contract_sha256": "23431134396d8740104bbfd88ab2cadd0192f614422cb86a64fb7ab174973a33", + "module_content_identity": { + "bytes": 36, + "git_blob": "561581e73cb27c7ab316ef290653e8d4d6df1280", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2" + }, + "native_repository": "fixture/collector-contract", + "package": { + "declared_name": "Fixture", + "manifest_path": "formal/manifest.json" + }, + "scope_content_identity": { + "import_files": [], + "scope_files": [ + { + "bytes": 21, + "git_blob": "ad8dd765494201f2801c519e4968fd7d5e9f681b", + "kind": "snapshot", + "path": "formal/SCOPE.md", + "repository": "fixture/collector-contract", + "sha256": "f02d203cd02fe51dce38f860a48502322f39c852cc5668b1fa4454ac9c0a9a85" + } + ] + }, + "target": "Demo.t", + "type_content_bytes": 15, + "type_content_sha256": "1cdf12659a464ffcd9691c1f56dac178e5a01a2ddc80e18afcf5e2e5ee9b639e", + "unresolved_fields": [] + } + ] + }, + "expected_classification": [ + "formal_statement_changed" + ], + "id": "actual_type_record_change", + "outside_hash_custody_example": { + "acquisition_id": "fixture-acquisition-2", + "artifact_id": "202", + "log_record_start_byte": 91, + "run_attempt": 2, + "run_id": "102" + }, + "qualification": "SYNTHETIC_UNQUALIFIED_LITERAL_ONLY", + "raw_input_changes": [ + { + "raw_base64": "RGVtby50IDogRmFsc2UK", + "role": "target_type_record" + } + ], + "same_digest_as_baseline": false, + "sha256": "c507727b90f939d5aad3a4eff41868ab84c8cb6bcb972b3c76be3ea00186fa8a" + }, + { + "canonical_ascii_preimage": "{\"domain\":\"formal-regression-inventory/v1\",\"domain_id\":\"fixture-only-domain\",\"targets\":[{\"accepted_formal_proof_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":35,\"sha256\":\"f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98\",\"source\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"start_byte\":25}}],\"accepted_formal_statement_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":21,\"sha256\":\"1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7\",\"source\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"start_byte\":0}}],\"compiler_dependency_options_identity\":{\"build_config\":[],\"compiler_identity\":{\"executable\":{\"bytes\":23,\"sha256\":\"4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3\"},\"version_output\":{\"bytes\":27,\"sha256\":\"02adc609bd41e61fbfaedd8c89919c9cc125e3cb9f806c4208f757e1819bd78f\"}},\"dependencies\":[{\"name\":\"fixture_dep\",\"revision\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}],\"dependency_lock\":{\"bytes\":86,\"git_blob\":\"61ec800f4939eb07f270dfb49e9082cb332ed2d1\",\"kind\":\"snapshot\",\"path\":\"formal/lake-manifest.json\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"1ab9294e46112743a4489f401e0ba4dcd6d8e595458ede8b2a71958593774be4\"},\"options\":[\"fixture-option=changed\"],\"print_options\":[\"pp.explicit=true\"],\"producer_sources\":[],\"runtime_identity\":{\"executables\":[{\"content\":{\"bytes\":23,\"sha256\":\"4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3\"},\"name\":\"compiler\"}],\"image_manifest\":null,\"platform\":\"synthetic-fixture-only\"},\"toolchain\":\"fixture-toolchain-1\"},\"format\":\"main-formal-gate/v1\",\"manifest_contract_sha256\":\"23431134396d8740104bbfd88ab2cadd0192f614422cb86a64fb7ab174973a33\",\"module_content_identity\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"native_repository\":\"fixture/collector-contract\",\"package\":{\"declared_name\":\"Fixture\",\"manifest_path\":\"formal/manifest.json\"},\"scope_content_identity\":{\"import_files\":[],\"scope_files\":[{\"bytes\":21,\"git_blob\":\"ad8dd765494201f2801c519e4968fd7d5e9f681b\",\"kind\":\"snapshot\",\"path\":\"formal/SCOPE.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"f02d203cd02fe51dce38f860a48502322f39c852cc5668b1fa4454ac9c0a9a85\"}]},\"target\":\"Demo.t\",\"type_content_bytes\":14,\"type_content_sha256\":\"41f2e67cfbe0ed463361466a589f2412c29e892507bee03d527fbd556d87c5ef\",\"unresolved_fields\":[]}]}", + "core": { + "domain": "formal-regression-inventory/v1", + "domain_id": "fixture-only-domain", + "targets": [ + { + "accepted_formal_proof_selector": [ + { + "link_id": "fixture-link", + "selector": { + "end_byte": 35, + "sha256": "f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98", + "source": { + "bytes": 36, + "git_blob": "561581e73cb27c7ab316ef290653e8d4d6df1280", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2" + }, + "start_byte": 25 + } + } + ], + "accepted_formal_statement_selector": [ + { + "link_id": "fixture-link", + "selector": { + "end_byte": 21, + "sha256": "1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7", + "source": { + "bytes": 36, + "git_blob": "561581e73cb27c7ab316ef290653e8d4d6df1280", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2" + }, + "start_byte": 0 + } + } + ], + "compiler_dependency_options_identity": { + "build_config": [], + "compiler_identity": { + "executable": { + "bytes": 23, + "sha256": "4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3" + }, + "version_output": { + "bytes": 27, + "sha256": "02adc609bd41e61fbfaedd8c89919c9cc125e3cb9f806c4208f757e1819bd78f" + } + }, + "dependencies": [ + { + "name": "fixture_dep", + "revision": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + } + ], + "dependency_lock": { + "bytes": 86, + "git_blob": "61ec800f4939eb07f270dfb49e9082cb332ed2d1", + "kind": "snapshot", + "path": "formal/lake-manifest.json", + "repository": "fixture/collector-contract", + "sha256": "1ab9294e46112743a4489f401e0ba4dcd6d8e595458ede8b2a71958593774be4" + }, + "options": [ + "fixture-option=changed" + ], + "print_options": [ + "pp.explicit=true" + ], + "producer_sources": [], + "runtime_identity": { + "executables": [ + { + "content": { + "bytes": 23, + "sha256": "4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3" + }, + "name": "compiler" + } + ], + "image_manifest": null, + "platform": "synthetic-fixture-only" + }, + "toolchain": "fixture-toolchain-1" + }, + "format": "main-formal-gate/v1", + "manifest_contract_sha256": "23431134396d8740104bbfd88ab2cadd0192f614422cb86a64fb7ab174973a33", + "module_content_identity": { + "bytes": 36, + "git_blob": "561581e73cb27c7ab316ef290653e8d4d6df1280", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2" + }, + "native_repository": "fixture/collector-contract", + "package": { + "declared_name": "Fixture", + "manifest_path": "formal/manifest.json" + }, + "scope_content_identity": { + "import_files": [], + "scope_files": [ + { + "bytes": 21, + "git_blob": "ad8dd765494201f2801c519e4968fd7d5e9f681b", + "kind": "snapshot", + "path": "formal/SCOPE.md", + "repository": "fixture/collector-contract", + "sha256": "f02d203cd02fe51dce38f860a48502322f39c852cc5668b1fa4454ac9c0a9a85" + } + ] + }, + "target": "Demo.t", + "type_content_bytes": 14, + "type_content_sha256": "41f2e67cfbe0ed463361466a589f2412c29e892507bee03d527fbd556d87c5ef", + "unresolved_fields": [] + } + ] + }, + "expected_classification": [ + "comparison_unknown", + "REVALIDATION_REQUIRED" + ], + "id": "actual_compiler_option_change", + "outside_hash_custody_example": { + "acquisition_id": "fixture-acquisition-2", + "artifact_id": "202", + "log_record_start_byte": 91, + "run_attempt": 2, + "run_id": "102" + }, + "qualification": "SYNTHETIC_UNQUALIFIED_LITERAL_ONLY", + "raw_input_changes": [ + { + "role": "effective_semantic_options", + "value": [ + "fixture-option=changed" + ] + } + ], + "same_digest_as_baseline": false, + "sha256": "5ff478abe3a20e67de8ec879e8a91930256dab1a68c8ea04263bc1296c59c4f3" + }, + { + "canonical_ascii_preimage": "{\"domain\":\"formal-regression-inventory/v1\",\"domain_id\":\"fixture-only-domain\",\"targets\":[{\"accepted_formal_proof_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":35,\"sha256\":\"f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98\",\"source\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"start_byte\":25}}],\"accepted_formal_statement_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":21,\"sha256\":\"1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7\",\"source\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"start_byte\":0}}],\"compiler_dependency_options_identity\":{\"build_config\":[],\"compiler_identity\":{\"executable\":{\"bytes\":23,\"sha256\":\"4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3\"},\"version_output\":{\"bytes\":27,\"sha256\":\"02adc609bd41e61fbfaedd8c89919c9cc125e3cb9f806c4208f757e1819bd78f\"}},\"dependencies\":[{\"name\":\"fixture_dep\",\"revision\":\"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"}],\"dependency_lock\":{\"bytes\":86,\"git_blob\":\"1a97166d199524376d09b0f60eaa58bf1cee2920\",\"kind\":\"snapshot\",\"path\":\"formal/lake-manifest.json\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"591852ad40ffc76759a05cab7d7884dca23d8c11286996dd7b723d2536012031\"},\"options\":[],\"print_options\":[\"pp.explicit=true\"],\"producer_sources\":[],\"runtime_identity\":{\"executables\":[{\"content\":{\"bytes\":23,\"sha256\":\"4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3\"},\"name\":\"compiler\"}],\"image_manifest\":null,\"platform\":\"synthetic-fixture-only\"},\"toolchain\":\"fixture-toolchain-1\"},\"format\":\"main-formal-gate/v1\",\"manifest_contract_sha256\":\"23431134396d8740104bbfd88ab2cadd0192f614422cb86a64fb7ab174973a33\",\"module_content_identity\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"native_repository\":\"fixture/collector-contract\",\"package\":{\"declared_name\":\"Fixture\",\"manifest_path\":\"formal/manifest.json\"},\"scope_content_identity\":{\"import_files\":[],\"scope_files\":[{\"bytes\":21,\"git_blob\":\"ad8dd765494201f2801c519e4968fd7d5e9f681b\",\"kind\":\"snapshot\",\"path\":\"formal/SCOPE.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"f02d203cd02fe51dce38f860a48502322f39c852cc5668b1fa4454ac9c0a9a85\"}]},\"target\":\"Demo.t\",\"type_content_bytes\":14,\"type_content_sha256\":\"41f2e67cfbe0ed463361466a589f2412c29e892507bee03d527fbd556d87c5ef\",\"unresolved_fields\":[]}]}", + "core": { + "domain": "formal-regression-inventory/v1", + "domain_id": "fixture-only-domain", + "targets": [ + { + "accepted_formal_proof_selector": [ + { + "link_id": "fixture-link", + "selector": { + "end_byte": 35, + "sha256": "f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98", + "source": { + "bytes": 36, + "git_blob": "561581e73cb27c7ab316ef290653e8d4d6df1280", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2" + }, + "start_byte": 25 + } + } + ], + "accepted_formal_statement_selector": [ + { + "link_id": "fixture-link", + "selector": { + "end_byte": 21, + "sha256": "1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7", + "source": { + "bytes": 36, + "git_blob": "561581e73cb27c7ab316ef290653e8d4d6df1280", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2" + }, + "start_byte": 0 + } + } + ], + "compiler_dependency_options_identity": { + "build_config": [], + "compiler_identity": { + "executable": { + "bytes": 23, + "sha256": "4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3" + }, + "version_output": { + "bytes": 27, + "sha256": "02adc609bd41e61fbfaedd8c89919c9cc125e3cb9f806c4208f757e1819bd78f" + } + }, + "dependencies": [ + { + "name": "fixture_dep", + "revision": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" + } + ], + "dependency_lock": { + "bytes": 86, + "git_blob": "1a97166d199524376d09b0f60eaa58bf1cee2920", + "kind": "snapshot", + "path": "formal/lake-manifest.json", + "repository": "fixture/collector-contract", + "sha256": "591852ad40ffc76759a05cab7d7884dca23d8c11286996dd7b723d2536012031" + }, + "options": [], + "print_options": [ + "pp.explicit=true" + ], + "producer_sources": [], + "runtime_identity": { + "executables": [ + { + "content": { + "bytes": 23, + "sha256": "4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3" + }, + "name": "compiler" + } + ], + "image_manifest": null, + "platform": "synthetic-fixture-only" + }, + "toolchain": "fixture-toolchain-1" + }, + "format": "main-formal-gate/v1", + "manifest_contract_sha256": "23431134396d8740104bbfd88ab2cadd0192f614422cb86a64fb7ab174973a33", + "module_content_identity": { + "bytes": 36, + "git_blob": "561581e73cb27c7ab316ef290653e8d4d6df1280", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2" + }, + "native_repository": "fixture/collector-contract", + "package": { + "declared_name": "Fixture", + "manifest_path": "formal/manifest.json" + }, + "scope_content_identity": { + "import_files": [], + "scope_files": [ + { + "bytes": 21, + "git_blob": "ad8dd765494201f2801c519e4968fd7d5e9f681b", + "kind": "snapshot", + "path": "formal/SCOPE.md", + "repository": "fixture/collector-contract", + "sha256": "f02d203cd02fe51dce38f860a48502322f39c852cc5668b1fa4454ac9c0a9a85" + } + ] + }, + "target": "Demo.t", + "type_content_bytes": 14, + "type_content_sha256": "41f2e67cfbe0ed463361466a589f2412c29e892507bee03d527fbd556d87c5ef", + "unresolved_fields": [] + } + ] + }, + "expected_classification": [ + "comparison_unknown", + "REVALIDATION_REQUIRED" + ], + "id": "actual_dependency_change", + "outside_hash_custody_example": { + "acquisition_id": "fixture-acquisition-2", + "artifact_id": "202", + "log_record_start_byte": 91, + "run_attempt": 2, + "run_id": "102" + }, + "qualification": "SYNTHETIC_UNQUALIFIED_LITERAL_ONLY", + "raw_input_changes": [ + { + "raw_base64": "eyJwYWNrYWdlcyI6W3sibmFtZSI6ImZpeHR1cmVfZGVwIiwicmV2IjoiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYiJ9XX0=", + "role": "dependency_lock" + } + ], + "same_digest_as_baseline": false, + "sha256": "ed156dc4afac2484f25ef5ec797258d72295a787f9fb642b913fa7854a34152e" + }, + { + "canonical_ascii_preimage": "{\"domain\":\"formal-regression-inventory/v1\",\"domain_id\":\"fixture-only-domain\",\"targets\":[{\"accepted_formal_proof_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":35,\"sha256\":\"f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98\",\"source\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"start_byte\":25}}],\"accepted_formal_statement_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":21,\"sha256\":\"1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7\",\"source\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"start_byte\":0}}],\"compiler_dependency_options_identity\":{\"build_config\":[],\"compiler_identity\":{\"executable\":{\"bytes\":23,\"sha256\":\"4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3\"},\"version_output\":{\"bytes\":27,\"sha256\":\"02adc609bd41e61fbfaedd8c89919c9cc125e3cb9f806c4208f757e1819bd78f\"}},\"dependencies\":[{\"name\":\"fixture_dep\",\"revision\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}],\"dependency_lock\":{\"bytes\":86,\"git_blob\":\"61ec800f4939eb07f270dfb49e9082cb332ed2d1\",\"kind\":\"snapshot\",\"path\":\"formal/lake-manifest.json\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"1ab9294e46112743a4489f401e0ba4dcd6d8e595458ede8b2a71958593774be4\"},\"options\":[],\"print_options\":[\"pp.explicit=true\"],\"producer_sources\":[],\"runtime_identity\":{\"executables\":[{\"content\":{\"bytes\":23,\"sha256\":\"4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3\"},\"name\":\"compiler\"}],\"image_manifest\":null,\"platform\":\"synthetic-fixture-only\"},\"toolchain\":\"fixture-toolchain-1\"},\"format\":\"main-formal-gate/v1\",\"manifest_contract_sha256\":\"23431134396d8740104bbfd88ab2cadd0192f614422cb86a64fb7ab174973a33\",\"module_content_identity\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"native_repository\":\"fixture/collector-contract\",\"package\":{\"declared_name\":\"Fixture\",\"manifest_path\":\"formal/manifest.json\"},\"scope_content_identity\":{\"import_files\":[],\"scope_files\":[{\"bytes\":29,\"git_blob\":\"556e657cbd587c06c70c92530a5f7e6c6f888eee\",\"kind\":\"snapshot\",\"path\":\"formal/SCOPE.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"ab55c1ef6f697d9f7469786b5b9a2b1e1f823376f8eef71325f20fe9aa0ddd40\"}]},\"target\":\"Demo.t\",\"type_content_bytes\":14,\"type_content_sha256\":\"41f2e67cfbe0ed463361466a589f2412c29e892507bee03d527fbd556d87c5ef\",\"unresolved_fields\":[]}]}", + "core": { + "domain": "formal-regression-inventory/v1", + "domain_id": "fixture-only-domain", + "targets": [ + { + "accepted_formal_proof_selector": [ + { + "link_id": "fixture-link", + "selector": { + "end_byte": 35, + "sha256": "f2e0ecca84b3b66bd77ebace02a52ddde1cd752ca09dd0ac351b36539c60dd98", + "source": { + "bytes": 36, + "git_blob": "561581e73cb27c7ab316ef290653e8d4d6df1280", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2" + }, + "start_byte": 25 + } + } + ], + "accepted_formal_statement_selector": [ + { + "link_id": "fixture-link", + "selector": { + "end_byte": 21, + "sha256": "1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7", + "source": { + "bytes": 36, + "git_blob": "561581e73cb27c7ab316ef290653e8d4d6df1280", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2" + }, + "start_byte": 0 + } + } + ], + "compiler_dependency_options_identity": { + "build_config": [], + "compiler_identity": { + "executable": { + "bytes": 23, + "sha256": "4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3" + }, + "version_output": { + "bytes": 27, + "sha256": "02adc609bd41e61fbfaedd8c89919c9cc125e3cb9f806c4208f757e1819bd78f" + } + }, + "dependencies": [ + { + "name": "fixture_dep", + "revision": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + } + ], + "dependency_lock": { + "bytes": 86, + "git_blob": "61ec800f4939eb07f270dfb49e9082cb332ed2d1", + "kind": "snapshot", + "path": "formal/lake-manifest.json", + "repository": "fixture/collector-contract", + "sha256": "1ab9294e46112743a4489f401e0ba4dcd6d8e595458ede8b2a71958593774be4" + }, + "options": [], + "print_options": [ + "pp.explicit=true" + ], + "producer_sources": [], + "runtime_identity": { + "executables": [ + { + "content": { + "bytes": 23, + "sha256": "4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3" + }, + "name": "compiler" + } + ], + "image_manifest": null, + "platform": "synthetic-fixture-only" + }, + "toolchain": "fixture-toolchain-1" + }, + "format": "main-formal-gate/v1", + "manifest_contract_sha256": "23431134396d8740104bbfd88ab2cadd0192f614422cb86a64fb7ab174973a33", + "module_content_identity": { + "bytes": 36, + "git_blob": "561581e73cb27c7ab316ef290653e8d4d6df1280", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2" + }, + "native_repository": "fixture/collector-contract", + "package": { + "declared_name": "Fixture", + "manifest_path": "formal/manifest.json" + }, + "scope_content_identity": { + "import_files": [], + "scope_files": [ + { + "bytes": 29, + "git_blob": "556e657cbd587c06c70c92530a5f7e6c6f888eee", + "kind": "snapshot", + "path": "formal/SCOPE.md", + "repository": "fixture/collector-contract", + "sha256": "ab55c1ef6f697d9f7469786b5b9a2b1e1f823376f8eef71325f20fe9aa0ddd40" + } + ] + }, + "target": "Demo.t", + "type_content_bytes": 14, + "type_content_sha256": "41f2e67cfbe0ed463361466a589f2412c29e892507bee03d527fbd556d87c5ef", + "unresolved_fields": [] + } + ] + }, + "expected_classification": [ + "scope_contract_changed", + "REVALIDATION_REQUIRED" + ], + "id": "actual_scope_change", + "outside_hash_custody_example": { + "acquisition_id": "fixture-acquisition-2", + "artifact_id": "202", + "log_record_start_byte": 91, + "run_attempt": 2, + "run_id": "102" + }, + "qualification": "SYNTHETIC_UNQUALIFIED_LITERAL_ONLY", + "raw_input_changes": [ + { + "raw_base64": "Q2hhbmdlZCBmaXh0dXJlIGRvbWFpbiBvbmx5Lgo=", + "role": "scope_file" + } + ], + "same_digest_as_baseline": false, + "sha256": "01127aa13ad6f9e145489e5ceaff15426926637de8245e98b11e8953de6820dd" + }, + { + "canonical_ascii_preimage": "{\"domain\":\"formal-regression-inventory/v1\",\"domain_id\":\"fixture-only-domain\",\"targets\":[{\"accepted_formal_proof_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":44,\"sha256\":\"e59be2f99ae700cd1b5b08e1d846749e4780e1ad0154cdc8dfcaa629ba3425e6\",\"source\":{\"bytes\":45,\"git_blob\":\"9c65448cca25d32f5118986efe1adaa137fee494\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"ea07bd71ab553e0232f887613de4b50fc9c0a45021a891958e8eda99a29969ba\"},\"start_byte\":25}}],\"accepted_formal_statement_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":21,\"sha256\":\"1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7\",\"source\":{\"bytes\":45,\"git_blob\":\"9c65448cca25d32f5118986efe1adaa137fee494\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"ea07bd71ab553e0232f887613de4b50fc9c0a45021a891958e8eda99a29969ba\"},\"start_byte\":0}}],\"compiler_dependency_options_identity\":{\"build_config\":[],\"compiler_identity\":{\"executable\":{\"bytes\":23,\"sha256\":\"4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3\"},\"version_output\":{\"bytes\":27,\"sha256\":\"02adc609bd41e61fbfaedd8c89919c9cc125e3cb9f806c4208f757e1819bd78f\"}},\"dependencies\":[{\"name\":\"fixture_dep\",\"revision\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}],\"dependency_lock\":{\"bytes\":86,\"git_blob\":\"61ec800f4939eb07f270dfb49e9082cb332ed2d1\",\"kind\":\"snapshot\",\"path\":\"formal/lake-manifest.json\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"1ab9294e46112743a4489f401e0ba4dcd6d8e595458ede8b2a71958593774be4\"},\"options\":[],\"print_options\":[\"pp.explicit=true\"],\"producer_sources\":[],\"runtime_identity\":{\"executables\":[{\"content\":{\"bytes\":23,\"sha256\":\"4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3\"},\"name\":\"compiler\"}],\"image_manifest\":null,\"platform\":\"synthetic-fixture-only\"},\"toolchain\":\"fixture-toolchain-1\"},\"format\":\"main-formal-gate/v1\",\"manifest_contract_sha256\":\"fccf609da35c66348adf969ef0717002ea5ef8f1674d325a5b3e9cfc310ffad7\",\"module_content_identity\":{\"bytes\":45,\"git_blob\":\"9c65448cca25d32f5118986efe1adaa137fee494\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"ea07bd71ab553e0232f887613de4b50fc9c0a45021a891958e8eda99a29969ba\"},\"native_repository\":\"fixture/collector-contract\",\"package\":{\"declared_name\":\"Fixture\",\"manifest_path\":\"formal/manifest.json\"},\"scope_content_identity\":{\"import_files\":[],\"scope_files\":[{\"bytes\":21,\"git_blob\":\"ad8dd765494201f2801c519e4968fd7d5e9f681b\",\"kind\":\"snapshot\",\"path\":\"formal/SCOPE.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"f02d203cd02fe51dce38f860a48502322f39c852cc5668b1fa4454ac9c0a9a85\"}]},\"target\":\"Demo.t\",\"type_content_bytes\":14,\"type_content_sha256\":\"41f2e67cfbe0ed463361466a589f2412c29e892507bee03d527fbd556d87c5ef\",\"unresolved_fields\":[]}]}", + "core": { + "domain": "formal-regression-inventory/v1", + "domain_id": "fixture-only-domain", + "targets": [ + { + "accepted_formal_proof_selector": [ + { + "link_id": "fixture-link", + "selector": { + "end_byte": 44, + "sha256": "e59be2f99ae700cd1b5b08e1d846749e4780e1ad0154cdc8dfcaa629ba3425e6", + "source": { + "bytes": 45, + "git_blob": "9c65448cca25d32f5118986efe1adaa137fee494", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "ea07bd71ab553e0232f887613de4b50fc9c0a45021a891958e8eda99a29969ba" + }, + "start_byte": 25 + } + } + ], + "accepted_formal_statement_selector": [ + { + "link_id": "fixture-link", + "selector": { + "end_byte": 21, + "sha256": "1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7", + "source": { + "bytes": 45, + "git_blob": "9c65448cca25d32f5118986efe1adaa137fee494", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "ea07bd71ab553e0232f887613de4b50fc9c0a45021a891958e8eda99a29969ba" + }, + "start_byte": 0 + } + } + ], + "compiler_dependency_options_identity": { + "build_config": [], + "compiler_identity": { + "executable": { + "bytes": 23, + "sha256": "4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3" + }, + "version_output": { + "bytes": 27, + "sha256": "02adc609bd41e61fbfaedd8c89919c9cc125e3cb9f806c4208f757e1819bd78f" + } + }, + "dependencies": [ + { + "name": "fixture_dep", + "revision": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + } + ], + "dependency_lock": { + "bytes": 86, + "git_blob": "61ec800f4939eb07f270dfb49e9082cb332ed2d1", + "kind": "snapshot", + "path": "formal/lake-manifest.json", + "repository": "fixture/collector-contract", + "sha256": "1ab9294e46112743a4489f401e0ba4dcd6d8e595458ede8b2a71958593774be4" + }, + "options": [], + "print_options": [ + "pp.explicit=true" + ], + "producer_sources": [], + "runtime_identity": { + "executables": [ + { + "content": { + "bytes": 23, + "sha256": "4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3" + }, + "name": "compiler" + } + ], + "image_manifest": null, + "platform": "synthetic-fixture-only" + }, + "toolchain": "fixture-toolchain-1" + }, + "format": "main-formal-gate/v1", + "manifest_contract_sha256": "fccf609da35c66348adf969ef0717002ea5ef8f1674d325a5b3e9cfc310ffad7", + "module_content_identity": { + "bytes": 45, + "git_blob": "9c65448cca25d32f5118986efe1adaa137fee494", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "ea07bd71ab553e0232f887613de4b50fc9c0a45021a891958e8eda99a29969ba" + }, + "native_repository": "fixture/collector-contract", + "package": { + "declared_name": "Fixture", + "manifest_path": "formal/manifest.json" + }, + "scope_content_identity": { + "import_files": [], + "scope_files": [ + { + "bytes": 21, + "git_blob": "ad8dd765494201f2801c519e4968fd7d5e9f681b", + "kind": "snapshot", + "path": "formal/SCOPE.md", + "repository": "fixture/collector-contract", + "sha256": "f02d203cd02fe51dce38f860a48502322f39c852cc5668b1fa4454ac9c0a9a85" + } + ] + }, + "target": "Demo.t", + "type_content_bytes": 14, + "type_content_sha256": "41f2e67cfbe0ed463361466a589f2412c29e892507bee03d527fbd556d87c5ef", + "unresolved_fields": [] + } + ] + }, + "expected_classification": [ + "proof_body_changed_IF_actual_selector_acceptance_and_complete_removal_control_qualify", + "manifest_contract_changed", + "REVALIDATION_REQUIRED", + "NO_STATEMENT_EQUIVALENCE_OR_ALIGNMENT_CLAIM" + ], + "id": "accepted_proof_body_only_module_edit_plus_manifest_refresh", + "outside_hash_custody_example": { + "acquisition_id": "fixture-acquisition-2", + "artifact_id": "202", + "log_record_start_byte": 91, + "run_attempt": 2, + "run_id": "102" + }, + "qualification": "SYNTHETIC_UNQUALIFIED_LITERAL_ONLY", + "raw_input_changes": [ + { + "raw_base64": "dGhlb3JlbSBEZW1vLnQgOiBUcnVlIDo9IGJ5IGV4YWN0IFRydWUuaW50cm8K", + "role": "formal_module" + }, + { + "raw_base64": "eyJmaWxlcyI6eyJmb3JtYWwvRml4dHVyZS9EZW1vLmxlYW4iOiJlYTA3YmQ3MWFiNTUzZTAyMzJmODg3NjEzZGU0YjUwZmM5YzBhNDUwMjFhODkxOTU4ZThlZGE5OWEyOTk2OWJhIn0sImZpeHR1cmVfb25seSI6dHJ1ZSwidGFyZ2V0cyI6WyJEZW1vLnQiXX0=", + "role": "native_manifest" + } + ], + "same_digest_as_baseline": false, + "sha256": "1e79cef0d148509119876ed49ab75d86bee2e0640b31be80e74ca2ef38a4cfc6" + }, + { + "canonical_ascii_preimage": "{\"domain\":\"formal-regression-inventory/v1\",\"domain_id\":\"fixture-only-domain\",\"targets\":[{\"accepted_formal_proof_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":34,\"sha256\":\"c87d75ebcadaf4bf29afd42a47421b3217890ac33121c0def324e413287197fc\",\"source\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"start_byte\":25}}],\"accepted_formal_statement_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":21,\"sha256\":\"1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7\",\"source\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"start_byte\":0}}],\"compiler_dependency_options_identity\":{\"build_config\":[],\"compiler_identity\":{\"executable\":{\"bytes\":23,\"sha256\":\"4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3\"},\"version_output\":{\"bytes\":27,\"sha256\":\"02adc609bd41e61fbfaedd8c89919c9cc125e3cb9f806c4208f757e1819bd78f\"}},\"dependencies\":[{\"name\":\"fixture_dep\",\"revision\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}],\"dependency_lock\":{\"bytes\":86,\"git_blob\":\"61ec800f4939eb07f270dfb49e9082cb332ed2d1\",\"kind\":\"snapshot\",\"path\":\"formal/lake-manifest.json\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"1ab9294e46112743a4489f401e0ba4dcd6d8e595458ede8b2a71958593774be4\"},\"options\":[],\"print_options\":[\"pp.explicit=true\"],\"producer_sources\":[],\"runtime_identity\":{\"executables\":[{\"content\":{\"bytes\":23,\"sha256\":\"4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3\"},\"name\":\"compiler\"}],\"image_manifest\":null,\"platform\":\"synthetic-fixture-only\"},\"toolchain\":\"fixture-toolchain-1\"},\"format\":\"main-formal-gate/v1\",\"manifest_contract_sha256\":\"23431134396d8740104bbfd88ab2cadd0192f614422cb86a64fb7ab174973a33\",\"module_content_identity\":{\"bytes\":36,\"git_blob\":\"561581e73cb27c7ab316ef290653e8d4d6df1280\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2\"},\"native_repository\":\"fixture/collector-contract\",\"package\":{\"declared_name\":\"Fixture\",\"manifest_path\":\"formal/manifest.json\"},\"scope_content_identity\":{\"import_files\":[],\"scope_files\":[{\"bytes\":21,\"git_blob\":\"ad8dd765494201f2801c519e4968fd7d5e9f681b\",\"kind\":\"snapshot\",\"path\":\"formal/SCOPE.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"f02d203cd02fe51dce38f860a48502322f39c852cc5668b1fa4454ac9c0a9a85\"}]},\"target\":\"Demo.t\",\"type_content_bytes\":14,\"type_content_sha256\":\"41f2e67cfbe0ed463361466a589f2412c29e892507bee03d527fbd556d87c5ef\",\"unresolved_fields\":[]}]}", + "core": { + "domain": "formal-regression-inventory/v1", + "domain_id": "fixture-only-domain", + "targets": [ + { + "accepted_formal_proof_selector": [ + { + "link_id": "fixture-link", + "selector": { + "end_byte": 34, + "sha256": "c87d75ebcadaf4bf29afd42a47421b3217890ac33121c0def324e413287197fc", + "source": { + "bytes": 36, + "git_blob": "561581e73cb27c7ab316ef290653e8d4d6df1280", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2" + }, + "start_byte": 25 + } + } + ], + "accepted_formal_statement_selector": [ + { + "link_id": "fixture-link", + "selector": { + "end_byte": 21, + "sha256": "1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7", + "source": { + "bytes": 36, + "git_blob": "561581e73cb27c7ab316ef290653e8d4d6df1280", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2" + }, + "start_byte": 0 + } + } + ], + "compiler_dependency_options_identity": { + "build_config": [], + "compiler_identity": { + "executable": { + "bytes": 23, + "sha256": "4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3" + }, + "version_output": { + "bytes": 27, + "sha256": "02adc609bd41e61fbfaedd8c89919c9cc125e3cb9f806c4208f757e1819bd78f" + } + }, + "dependencies": [ + { + "name": "fixture_dep", + "revision": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + } + ], + "dependency_lock": { + "bytes": 86, + "git_blob": "61ec800f4939eb07f270dfb49e9082cb332ed2d1", + "kind": "snapshot", + "path": "formal/lake-manifest.json", + "repository": "fixture/collector-contract", + "sha256": "1ab9294e46112743a4489f401e0ba4dcd6d8e595458ede8b2a71958593774be4" + }, + "options": [], + "print_options": [ + "pp.explicit=true" + ], + "producer_sources": [], + "runtime_identity": { + "executables": [ + { + "content": { + "bytes": 23, + "sha256": "4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3" + }, + "name": "compiler" + } + ], + "image_manifest": null, + "platform": "synthetic-fixture-only" + }, + "toolchain": "fixture-toolchain-1" + }, + "format": "main-formal-gate/v1", + "manifest_contract_sha256": "23431134396d8740104bbfd88ab2cadd0192f614422cb86a64fb7ab174973a33", + "module_content_identity": { + "bytes": 36, + "git_blob": "561581e73cb27c7ab316ef290653e8d4d6df1280", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "01c35a33c99b94f78f1fadf5dfc3fc2e27793f180196595e361184771da4c5e2" + }, + "native_repository": "fixture/collector-contract", + "package": { + "declared_name": "Fixture", + "manifest_path": "formal/manifest.json" + }, + "scope_content_identity": { + "import_files": [], + "scope_files": [ + { + "bytes": 21, + "git_blob": "ad8dd765494201f2801c519e4968fd7d5e9f681b", + "kind": "snapshot", + "path": "formal/SCOPE.md", + "repository": "fixture/collector-contract", + "sha256": "f02d203cd02fe51dce38f860a48502322f39c852cc5668b1fa4454ac9c0a9a85" + } + ] + }, + "target": "Demo.t", + "type_content_bytes": 14, + "type_content_sha256": "41f2e67cfbe0ed463361466a589f2412c29e892507bee03d527fbd556d87c5ef", + "unresolved_fields": [] + } + ] + }, + "expected_classification": [ + "formal_selector_changed", + "NO_PRINTED_TYPE_OR_KERNEL_FAILURE_INFERENCE" + ], + "id": "selector_only_change_same_source_and_type", + "outside_hash_custody_example": { + "acquisition_id": "fixture-acquisition-2", + "artifact_id": "202", + "log_record_start_byte": 91, + "run_attempt": 2, + "run_id": "102" + }, + "qualification": "SYNTHETIC_UNQUALIFIED_LITERAL_ONLY", + "raw_input_changes": [], + "same_digest_as_baseline": false, + "sha256": "364dc7d33c64bc68faf197b77e1abbdd8cd4ea0472c44f67712d5dd58a9dadb1" + }, + { + "canonical_ascii_preimage": "{\"domain\":\"formal-regression-inventory/v1\",\"domain_id\":\"fixture-only-domain\",\"targets\":[{\"accepted_formal_proof_selector\":[{\"link_id\":\"fixture-link\",\"selector\":null}],\"accepted_formal_statement_selector\":[{\"link_id\":\"fixture-link\",\"selector\":{\"end_byte\":21,\"sha256\":\"1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7\",\"source\":{\"bytes\":45,\"git_blob\":\"9c65448cca25d32f5118986efe1adaa137fee494\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"ea07bd71ab553e0232f887613de4b50fc9c0a45021a891958e8eda99a29969ba\"},\"start_byte\":0}}],\"compiler_dependency_options_identity\":{\"build_config\":[],\"compiler_identity\":{\"executable\":{\"bytes\":23,\"sha256\":\"4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3\"},\"version_output\":{\"bytes\":27,\"sha256\":\"02adc609bd41e61fbfaedd8c89919c9cc125e3cb9f806c4208f757e1819bd78f\"}},\"dependencies\":[{\"name\":\"fixture_dep\",\"revision\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"}],\"dependency_lock\":{\"bytes\":86,\"git_blob\":\"61ec800f4939eb07f270dfb49e9082cb332ed2d1\",\"kind\":\"snapshot\",\"path\":\"formal/lake-manifest.json\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"1ab9294e46112743a4489f401e0ba4dcd6d8e595458ede8b2a71958593774be4\"},\"options\":[],\"print_options\":[\"pp.explicit=true\"],\"producer_sources\":[],\"runtime_identity\":{\"executables\":[{\"content\":{\"bytes\":23,\"sha256\":\"4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3\"},\"name\":\"compiler\"}],\"image_manifest\":null,\"platform\":\"synthetic-fixture-only\"},\"toolchain\":\"fixture-toolchain-1\"},\"format\":\"main-formal-gate/v1\",\"manifest_contract_sha256\":\"fccf609da35c66348adf969ef0717002ea5ef8f1674d325a5b3e9cfc310ffad7\",\"module_content_identity\":{\"bytes\":45,\"git_blob\":\"9c65448cca25d32f5118986efe1adaa137fee494\",\"kind\":\"snapshot\",\"path\":\"formal/Fixture/Demo.lean\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"ea07bd71ab553e0232f887613de4b50fc9c0a45021a891958e8eda99a29969ba\"},\"native_repository\":\"fixture/collector-contract\",\"package\":{\"declared_name\":\"Fixture\",\"manifest_path\":\"formal/manifest.json\"},\"scope_content_identity\":{\"import_files\":[],\"scope_files\":[{\"bytes\":21,\"git_blob\":\"ad8dd765494201f2801c519e4968fd7d5e9f681b\",\"kind\":\"snapshot\",\"path\":\"formal/SCOPE.md\",\"repository\":\"fixture/collector-contract\",\"sha256\":\"f02d203cd02fe51dce38f860a48502322f39c852cc5668b1fa4454ac9c0a9a85\"}]},\"target\":\"Demo.t\",\"type_content_bytes\":14,\"type_content_sha256\":\"41f2e67cfbe0ed463361466a589f2412c29e892507bee03d527fbd556d87c5ef\",\"unresolved_fields\":[]}]}", + "core": { + "domain": "formal-regression-inventory/v1", + "domain_id": "fixture-only-domain", + "targets": [ + { + "accepted_formal_proof_selector": [ + { + "link_id": "fixture-link", + "selector": null + } + ], + "accepted_formal_statement_selector": [ + { + "link_id": "fixture-link", + "selector": { + "end_byte": 21, + "sha256": "1a47f8f6ea69cf20d549a5d5eb01a743e10b2768a35d53cbd428d6e74ce9a5c7", + "source": { + "bytes": 45, + "git_blob": "9c65448cca25d32f5118986efe1adaa137fee494", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "ea07bd71ab553e0232f887613de4b50fc9c0a45021a891958e8eda99a29969ba" + }, + "start_byte": 0 + } + } + ], + "compiler_dependency_options_identity": { + "build_config": [], + "compiler_identity": { + "executable": { + "bytes": 23, + "sha256": "4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3" + }, + "version_output": { + "bytes": 27, + "sha256": "02adc609bd41e61fbfaedd8c89919c9cc125e3cb9f806c4208f757e1819bd78f" + } + }, + "dependencies": [ + { + "name": "fixture_dep", + "revision": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + } + ], + "dependency_lock": { + "bytes": 86, + "git_blob": "61ec800f4939eb07f270dfb49e9082cb332ed2d1", + "kind": "snapshot", + "path": "formal/lake-manifest.json", + "repository": "fixture/collector-contract", + "sha256": "1ab9294e46112743a4489f401e0ba4dcd6d8e595458ede8b2a71958593774be4" + }, + "options": [], + "print_options": [ + "pp.explicit=true" + ], + "producer_sources": [], + "runtime_identity": { + "executables": [ + { + "content": { + "bytes": 23, + "sha256": "4f749fbca23888d85786dbe39f1f923f4ef70ad864f9ec657b6f170328b4eac3" + }, + "name": "compiler" + } + ], + "image_manifest": null, + "platform": "synthetic-fixture-only" + }, + "toolchain": "fixture-toolchain-1" + }, + "format": "main-formal-gate/v1", + "manifest_contract_sha256": "fccf609da35c66348adf969ef0717002ea5ef8f1674d325a5b3e9cfc310ffad7", + "module_content_identity": { + "bytes": 45, + "git_blob": "9c65448cca25d32f5118986efe1adaa137fee494", + "kind": "snapshot", + "path": "formal/Fixture/Demo.lean", + "repository": "fixture/collector-contract", + "sha256": "ea07bd71ab553e0232f887613de4b50fc9c0a45021a891958e8eda99a29969ba" + }, + "native_repository": "fixture/collector-contract", + "package": { + "declared_name": "Fixture", + "manifest_path": "formal/manifest.json" + }, + "scope_content_identity": { + "import_files": [], + "scope_files": [ + { + "bytes": 21, + "git_blob": "ad8dd765494201f2801c519e4968fd7d5e9f681b", + "kind": "snapshot", + "path": "formal/SCOPE.md", + "repository": "fixture/collector-contract", + "sha256": "f02d203cd02fe51dce38f860a48502322f39c852cc5668b1fa4454ac9c0a9a85" + } + ] + }, + "target": "Demo.t", + "type_content_bytes": 14, + "type_content_sha256": "41f2e67cfbe0ed463361466a589f2412c29e892507bee03d527fbd556d87c5ef", + "unresolved_fields": [] + } + ] + }, + "expected_classification": [ + "formal_source_changed_unscoped", + "formal_selector_changed", + "manifest_contract_changed", + "REVALIDATION_REQUIRED", + "NO_PROOF_ONLY_GUESS" + ], + "id": "same_module_edit_missing_proof_selector", + "outside_hash_custody_example": { + "acquisition_id": "fixture-acquisition-2", + "artifact_id": "202", + "log_record_start_byte": 91, + "run_attempt": 2, + "run_id": "102" + }, + "qualification": "SYNTHETIC_UNQUALIFIED_LITERAL_ONLY", + "raw_input_changes": [ + { + "raw_base64": "dGhlb3JlbSBEZW1vLnQgOiBUcnVlIDo9IGJ5IGV4YWN0IFRydWUuaW50cm8K", + "role": "formal_module" + }, + { + "raw_base64": "eyJmaWxlcyI6eyJmb3JtYWwvRml4dHVyZS9EZW1vLmxlYW4iOiJlYTA3YmQ3MWFiNTUzZTAyMzJmODg3NjEzZGU0YjUwZmM5YzBhNDUwMjFhODkxOTU4ZThlZGE5OWEyOTk2OWJhIn0sImZpeHR1cmVfb25seSI6dHJ1ZSwidGFyZ2V0cyI6WyJEZW1vLnQiXX0=", + "role": "native_manifest" + } + ], + "same_digest_as_baseline": false, + "sha256": "ebf1d7f9ed021c8724d19f4320f2f271fbd77bc490f68720fb3ab11817e8fbed" + } + ], + "formula": "formal_inventory_sha256 = lowercase_hex(SHA256(CanonicalASCII(InventoryCore))). CanonicalASCII is precisely lexical_rules.json: sorted object keys, compact separators, ensure_ascii=true, no nonfinite values, ASCII bytes and NO trailing newline. No prefix/suffix, extra digest wrapper or raw TargetStatement is hashed.", + "kind": "SMALL_DECLARATIVE_BYTE_CONFORMANCE_NOT_IMPLEMENTATION_TEST", + "negative_declarations": [ + { + "expected": "REFUSE_DUPLICATE_IDENTITY; no accepted digest", + "id": "duplicate_target_identity", + "input": "repeat baseline target row twice" + }, + { + "expected": "DIAGNOSTIC_ONLY; formal_inventory_sha256=null; no type-null semantic-change inference", + "id": "missing_required_type_record", + "input": "type_content_sha256=null,type_content_bytes=null;unresolved_fields=[type_content_bytes,type_content_sha256] sorted lexically" + }, + { + "expected": "NO_ACCEPTED_CORE_OR_DIGEST; no empty/subset fallback", + "id": "unknown_target_enumeration", + "input": "actual manifest target set unavailable/ambiguous" + }, + { + "expected": "REFUSE_REVALIDATION", + "id": "inconsistent_detached_digest", + "input": "detached formal_inventory_sha256 differs from independently projected candidate core" + } + ], + "qualification": "ALL_RAW_INPUTS_AND_CONTEXTS_ARE_SYNTHETIC; NO_REAL_NATIVE_OR_MAPPING_OR_REVIEW_EVIDENCE", + "schema_version": 1 +} diff --git a/tests/test_formal_regression.py b/tests/test_formal_regression.py new file mode 100644 index 000000000..5bd5ec295 --- /dev/null +++ b/tests/test_formal_regression.py @@ -0,0 +1,1100 @@ +"""Frozen independent first-core contract controls; execution is hosted only. + +The accepted conformance data are synthetic byte oracles. The separate proposed +internal collection profile carries no native, mapping, review or custody authority. +No working implementation was used to derive these expected values. +""" +import copy +import base64 +import re +import hashlib +import json +from pathlib import Path +import unittest + +from architecture.formal_regression import ( + decode_request, decode_policy, request_key, content_inventory, inventory_sha256, +) + +ROOT = Path(__file__).resolve().parents[1] +BASELINE = "4a469c57ba103d8937795c709b59765a689ae24f92b6ee1d55ddc74037b849e6" + + +def wire(value): + return json.dumps(value, sort_keys=True, separators=(",", ":"), + ensure_ascii=True, allow_nan=False).encode("ascii") + + +class ContractControls(unittest.TestCase): + def setUp(self): + self.vectors = json.loads((ROOT / "tests/fixtures/formal_regression/inventory-conformance.json").read_bytes()) + self.profile = json.loads((ROOT / "tests/fixtures/formal_regression/control-plan.json").read_bytes())["synthetic_test_boundary_profile"] + + def core(self): + return copy.deepcopy(self.vectors["cases"][0]["core"]) + + def request(self): + return copy.deepcopy(self.profile["request"]) + + def policy(self): + return copy.deepcopy(self.profile["diagnostic_policy"]) + + def reject_core(self, path, value=None, delete=False): + core = self.core() + self.assertEqual(inventory_sha256(core), BASELINE) + at = core + for part in path[:-1]: + at = at[part] + if delete: + del at[path[-1]] + else: + at[path[-1]] = value + with self.assertRaises(ValueError): + inventory_sha256(core) + + def collection(self, mutation=None): + profile = copy.deepcopy(self.profile) + self.assert_held_profile(profile) + if mutation is not None: + mutation(profile) + return content_inventory(profile["records"], profile["diagnostic_policy"], + profile["membership"], profile["acceptances"]) + + def collection_refusal(self, mutation, reason): + self.assert_collection_baseline(self.collection()) + result = self.collection(mutation) + self.assertIsNone(result["formal_inventory_sha256"]) + self.assertIn(reason, result["issues"]) + self.assertEqual(result["issues"], sorted(set(result["issues"]))) + + def assert_wire_shape(self, value, shape): + """Test-only fixture integrity; never supplies native qualification.""" + types = self.profile["wire_contract"]["types"] + if isinstance(shape, str) and shape in types: + return self.assert_wire_shape(value, types[shape]) + if isinstance(shape, str): + if shape == "null": + self.assertIsNone(value) + elif shape in ["uint", "positive_int"]: + self.assertIs(type(value), int) + self.assertGreaterEqual(value, 1 if shape == "positive_int" else 0) + else: + self.assertIs(type(value), str) + if shape != "string": + self.assertNotEqual(value, "") + patterns = {"hex40": r"[0-9a-f]{40}", "sha256": r"[0-9a-f]{64}", + "repository": r"[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+", + "name": r"[A-Za-z_][A-Za-z0-9_.']*"} + if shape in patterns: + self.assertIsNotNone(re.fullmatch(patterns[shape], value)) + if shape == "path": + self.assertFalse(value.startswith("/")) + self.assertNotIn("\\", value) + self.assertNotIn(":", value) + self.assertTrue(all(part not in ["", ".", ".."] for part in value.split("/"))) + self.assertTrue(all(ord(c) >= 32 and ord(c) != 127 for c in value)) + if shape == "base64": + self.assertEqual(base64.b64encode(base64.b64decode(value, validate=True)).decode("ascii"), value) + return + kind = shape["kind"] + if kind == "object": + self.assertIs(type(value), dict) + self.assertEqual(set(value), set(shape["fields"])) + for key, child in shape["fields"].items(): + self.assert_wire_shape(value[key], child) + elif kind == "array": + self.assertIs(type(value), list) + self.assertGreaterEqual(len(value), shape["min"]) + if "max" in shape: + self.assertLessEqual(len(value), shape["max"]) + for item in value: + self.assert_wire_shape(item, shape["item"]) + if "unique_by" in shape: + keys = [] + for item in value: + pieces = [] + for path in shape["unique_by"]: + at = item + for part in path.split("."): + at = at[part] + pieces.append(at) + keys.append(wire(pieces if shape["unique_by"] else item)) + self.assertEqual(len(keys), len(set(keys))) + elif kind == "map": + self.assertIs(type(value), dict) + for key, child in value.items(): + self.assert_wire_shape(key, shape["key"]) + self.assert_wire_shape(child, shape["value"]) + elif kind == "enum": + self.assertTrue(any(type(value) is type(item) and value == item for item in shape["values"])) + elif kind == "nullable": + if value is not None: + self.assert_wire_shape(value, shape["item"]) + elif kind == "union": + branches = [] + for candidate in shape["items"]: + try: + self.assert_wire_shape(value, candidate) + except AssertionError: + branches.append(False) + else: + branches.append(True) + self.assertEqual(branches.count(True), 1) + else: + self.fail("unknown fixture schema kind") + + def assert_held_profile(self, profile): + """Check every raw fixture prerequisite before an isolated mutation.""" + for key, typename in [("membership", "Membership"), ("acceptances", "Acceptances"), ("diagnostic_policy", "DiagnosticPolicy")]: + self.assert_wire_shape(profile[key], typename) + membership = profile["membership"] + self.assertEqual(profile["request"]["policy_sha256"], hashlib.sha256(wire(profile["diagnostic_policy"])).hexdigest()) + selected = profile["request"]["base" if membership["side"] == "base" else "checked_merge"] + self.assertEqual(membership["snapshot"], selected) + rows = {} + for row in membership["sources"]: + ref = row["ref"] + raw = base64.b64decode(row["raw_base64"], validate=True) + self.assertEqual(len(raw), ref["bytes"]) + self.assertEqual(hashlib.sha256(raw).hexdigest(), ref["sha256"]) + self.assertEqual(hashlib.sha1(b"blob " + str(len(raw)).encode("ascii") + b"\0" + raw).hexdigest(), ref["git_blob"]) + identity = (ref["repository"], ref["path"]) + self.assertNotIn(identity, rows) + rows[identity] = (ref, raw, row) + if row["side"] != "origin": + self.assertEqual(row["side"], membership["side"]) + self.assertEqual((ref["repository"], ref["commit"]), (selected["repository"], selected["commit"])) + def resolved(ref): + original, raw, row = rows[(ref["repository"], ref["path"])] + self.assertEqual(ref, original) + return raw + def refs(value): + if isinstance(value, dict): + if set(value) == {"repository", "commit", "path", "git_blob", "sha256", "bytes"}: + resolved(value) + else: + for child in value.values(): + refs(child) + elif isinstance(value, list): + for child in value: + refs(child) + for value in [membership["role_inputs"], membership["target_inputs"], membership["producer_observation"], membership["producer_observation_ref"], profile["records"], profile["diagnostic_policy"]]: + refs(value) + native_row = next(row for row in membership["sources"] if row["role"] == "native_manifest") + native = json.loads(resolved(native_row["ref"])) + self.assert_wire_shape(native, "NativeManifest") + self.assertEqual(membership["package"], {"declared_name": native["package"], "manifest_path": native_row["ref"]["path"]}) + names = [target["name"] for target in native["targets"]] + self.assertEqual(sorted(names), sorted(membership["native_targets"])) + self.assertEqual(sorted(names), sorted(record["target"] for record in profile["records"])) + self.assertEqual(sorted(names), sorted(item["target"] for item in membership["target_inputs"])) + candidate = {path: (ref, raw) for (repo, path), (ref, raw, row) in rows.items() if row["side"] == membership["side"]} + self.assertEqual(set(candidate), set(native["files"]) | set(native["unbound_files"])) + for path, digest in native["files"].items(): + self.assertEqual(candidate[path][0]["sha256"], digest) + self.assertEqual(candidate["formal/lean-toolchain"][1].decode("ascii").strip(), native["lean_toolchain"]) + root_imports = candidate[native["package_root"] + "/" + native["root_module"] + ".lean"][1].decode("utf-8").splitlines() + self.assertEqual(root_imports, ["import " + module[:-5].replace("/", ".") for module in native["source_modules"]]) + lock = json.loads(resolved(profile["records"][0]["compiler_context"]["dependency_lock_ref"])) + self.assert_wire_shape(lock, "LakeLock") + dependencies = {item["name"]: item["rev"] for item in lock["packages"]} + self.assertEqual(dependencies, native["dependency_revisions"]) + self.assertEqual(dependencies, {item["name"]: item["revision"] for item in membership["native_dependencies"]}) + observation = membership["producer_observation"] + self.assertEqual(json.loads(resolved(membership["producer_observation_ref"])), observation) + policy = profile["diagnostic_policy"]["native_producer_policies"][0] + self.assertEqual((policy["workflow_source_ref"]["repository"], policy["workflow_source_ref"]["commit"]), + (profile["request"]["control"]["repository"], profile["request"]["control"]["commit"])) + self.assertEqual(policy["toolchain"], native["lean_toolchain"]) + self.assertEqual(policy["print_options"], observation["print_options"]) + self.assertEqual(membership["print_options"], observation["print_options"]) + self.assertEqual(policy["runtime_identity"], observation["runtime_identity"]) + self.assertEqual(policy["source_control_files"], dict(membership["role_inputs"], target_inputs=membership["target_inputs"])) + self.assertEqual(policy["dependency_policy"], {"lock_ref": observation["dependency_lock_ref"], "revisions": observation["dependencies"]}) + producer_keys = lambda values: sorted(wire(value) for value in values) + self.assertEqual(producer_keys(membership["role_inputs"]["producer_sources"]), producer_keys([policy["workflow_source_ref"]] + policy["supervisor_source_refs"])) + for ref, observed in [(observation["compiler_executable_ref"], "executable"), (observation["compiler_version_ref"], "version_output")]: + resolved(ref) + self.assertEqual({key: ref[key] for key in ["bytes", "sha256"]}, profile["records"][0]["compiler_context"]["compiler_identity"][observed]) + for item in observation["runtime_executable_refs"]: + resolved(item["ref"]) + executable = next(row for row in observation["runtime_identity"]["executables"] if row["name"] == item["name"]) + self.assertEqual(executable["content"], {key: item["ref"][key] for key in ["bytes", "sha256"]}) + module_paths = {module[:-5].replace("/", "."): native["package_root"] + "/" + module for module in native["source_modules"]} + def imports(path, seen): + for line in candidate[path][1].decode("utf-8").splitlines(): + if line.startswith("import "): + imported = module_paths[line[7:]] + if imported not in seen: + seen.add(imported) + imports(imported, seen) + return seen + for record in profile["records"]: + self.assert_wire_shape(record, "TargetStatement") + target = next(item for item in native["targets"] if item["name"] == record["target"]) + self.assertEqual(record["manifest_ref"], native_row["ref"]) + self.assertEqual(record["module_ref"]["path"], native["package_root"] + "/" + target["module"]) + self.assertEqual(record["scope_ref"]["path"], native["package_root"] + "/SCOPE.md") + origin = next(item for item in native["sources"] if item["id"] == target["source"]) + self.assertEqual({key: record["origin_ref"][key] for key in ["repository", "commit", "path", "bytes", "sha256"]}, {key: origin[key] for key in ["repository", "commit", "path", "bytes", "sha256"]}) + self.assertEqual(record["checked_local_copy_ref"]["path"], origin["local_copy"]) + self.assertEqual(resolved(record["origin_ref"]), resolved(record["checked_local_copy_ref"])) + self.assertIn(target["informal_anchor"].encode("utf-8"), resolved(record["checked_local_copy_ref"])) + context = record["compiler_context"] + self.assertEqual(context["toolchain"], observation["toolchain"]) + self.assertEqual(context["options"], observation["options"]) + self.assertEqual(context["runtime_identity"], observation["runtime_identity"]) + self.assertEqual(context["dependency_revisions"], observation["dependencies"]) + self.assertEqual(producer_keys(context["producer_source_refs"]), producer_keys(membership["role_inputs"]["producer_sources"])) + expected_imports = imports(record["module_ref"]["path"], set()) + target_input = next(item for item in membership["target_inputs"] if item["target"] == record["target"]) + self.assertEqual({ref["path"] for ref in target_input["imports"]}, expected_imports) + for link in profile["acceptances"]["links"]: + record = next(item for item in profile["records"] if item["target"] == link["target"]) + for field in ["formal_statement_selector", "formal_proof_selector"]: + selected_slice = link[field] + if selected_slice is not None: + ref = record["module_ref"] + self.assertEqual(selected_slice["source"], dict(kind="snapshot", **{key: value for key, value in ref.items() if key != "commit"})) + raw = resolved(ref) + start, end = selected_slice["start_byte"], selected_slice["end_byte"] + self.assertLess(start, end) + self.assertLessEqual(end, len(raw)) + self.assertEqual(hashlib.sha256(raw[start:end]).hexdigest(), selected_slice["sha256"]) + self.assertEqual(wire(profile["expected_diagnostic_core"]), profile["expected_diagnostic_ascii_preimage"].encode("ascii")) + self.assertEqual(hashlib.sha256(wire(profile["expected_diagnostic_core"])).hexdigest(), profile["expected_diagnostic_sha256"]) + + def assert_collection_baseline(self, result): + self.assertIsNone(result["formal_inventory_sha256"]) + self.assertEqual(result["core"], self.profile["expected_diagnostic_core"]) + self.assertEqual(result["diagnostic_inventory_sha256"], self.profile["expected_diagnostic_sha256"]) + self.assertEqual(result["issues"], self.profile["expected_issues"]) + + def mutate_path(self, profile, path, value=None, delete=False): + at = profile + for part in path[:-1]: + at = at[part] + if delete: + del at[path[-1]] + else: + at[path[-1]] = value + + def rewrite_observation_raw(self, profile): + """Test-only alternate raw observation bytes, with all full refs retained.""" + membership = profile["membership"] + row = next(item for item in membership["sources"] if item["role"] == "producer_observation") + raw = wire(membership["producer_observation"]) + ref = dict(row["ref"], bytes=len(raw), sha256=hashlib.sha256(raw).hexdigest(), + git_blob=hashlib.sha1(b"blob " + str(len(raw)).encode("ascii") + b"\0" + raw).hexdigest()) + row["raw_base64"] = base64.b64encode(raw).decode("ascii") + row["ref"] = ref + membership["producer_observation_ref"] = copy.deepcopy(ref) + + def mutate_native_manifest_wire(self, profile, path, value): + """One malformed raw native wire condition, with full raw-ref joins held.""" + row = next(item for item in profile["membership"]["sources"] if item["role"] == "native_manifest") + native = json.loads(base64.b64decode(row["raw_base64"], validate=True)) + self.mutate_path(native, path, copy.deepcopy(value)) + raw = wire(native) + ref = dict(row["ref"], bytes=len(raw), sha256=hashlib.sha256(raw).hexdigest(), + git_blob=hashlib.sha1(b"blob " + str(len(raw)).encode("ascii") + b"\0" + raw).hexdigest()) + row["raw_base64"] = base64.b64encode(raw).decode("ascii") + row["ref"] = ref + for record in profile["records"]: + record["manifest_ref"] = copy.deepcopy(ref) + + def mutate_raw_observation_wire(self, profile): + row = next(item for item in profile["membership"]["sources"] if item["role"] == "producer_observation") + value = json.loads(base64.b64decode(row["raw_base64"], validate=True)) + value["unadmitted"] = "forged-extra" + raw = wire(value) + ref = dict(row["ref"], bytes=len(raw), sha256=hashlib.sha256(raw).hexdigest(), + git_blob=hashlib.sha1(b"blob " + str(len(raw)).encode("ascii") + b"\0" + raw).hexdigest()) + row["raw_base64"] = base64.b64encode(raw).decode("ascii") + row["ref"] = ref + profile["membership"]["producer_observation_ref"] = copy.deepcopy(ref) + + def permute_unordered_inputs(self, profile): + membership = profile["membership"] + profile["records"].reverse() + profile["acceptances"]["links"].reverse() + for field in ["sources", "native_targets", "native_dependencies", "target_inputs"]: + membership[field].reverse() + for values in membership["role_inputs"].values(): + values.reverse() + for target in membership["target_inputs"]: + target["imports"].reverse() + observation = membership["producer_observation"] + observation["dependencies"].reverse() + observation["runtime_identity"]["executables"].reverse() + observation["runtime_executable_refs"].reverse() + for record in profile["records"]: + record["compiler_context"]["dependency_revisions"].reverse() + record["compiler_context"]["producer_source_refs"].reverse() + record["compiler_context"]["runtime_identity"]["executables"].reverse() + producer = profile["diagnostic_policy"]["native_producer_policies"][0] + producer["runtime_identity"]["executables"].reverse() + producer["dependency_policy"]["revisions"].reverse() + for field in ["build_config", "producer_sources", "scope_files", "import_files", "target_inputs"]: + producer["source_control_files"][field].reverse() + for target in producer["source_control_files"]["target_inputs"]: + target["imports"].reverse() + self.rewrite_observation_raw(profile) + + def reverse_effective_options(self, profile, field): + membership = profile["membership"] + membership["producer_observation"][field].reverse() + if field == "options": + for record in profile["records"]: + record["compiler_context"]["options"].reverse() + else: + membership["print_options"].reverse() + profile["diagnostic_policy"]["native_producer_policies"][0]["print_options"].reverse() + self.rewrite_observation_raw(profile) + + + def test_inventory_baseline_hash(self): + core = self.core() + self.assertEqual(inventory_sha256(core), '4a469c57ba103d8937795c709b59765a689ae24f92b6ee1d55ddc74037b849e6') + + def test_recollection_keeps_content_digest(self): + first_core = self.vectors["cases"][0]["core"] + second_core = self.vectors["cases"][1]["core"] + self.assertEqual(inventory_sha256(first_core), inventory_sha256(second_core)) + self.assertEqual(inventory_sha256(first_core), BASELINE) + + def test_seven_content_deltas(self): + baseline_hash = inventory_sha256(self.core()) + changed_hashes = [inventory_sha256(case["core"]) for case in self.vectors["cases"][2:9]] + self.assertEqual(len(set(changed_hashes)), 7) + self.assertNotIn(baseline_hash, changed_hashes) + + def test_unknown_required_type_is_diagnostic(self): + result = self.collection() + self.assertIsNone(result["formal_inventory_sha256"]) + self.assertIsNotNone(result["diagnostic_inventory_sha256"]) + self.assertEqual(result["core"]["targets"][0]["unresolved_fields"], ["type_content_bytes", "type_content_sha256"]) + + self.assert_collection_baseline(result) + self.assertEqual([target["target"] for target in result["core"]["targets"]], ["Demo.t", "Demo.unlinked"]) + for target in result["core"]["targets"]: + self.assertEqual(target["unresolved_fields"], ["type_content_bytes", "type_content_sha256"]) + self.assertEqual(result["core"]["targets"][1]["accepted_formal_statement_selector"], []) + self.assertEqual(result["core"]["targets"][1]["accepted_formal_proof_selector"], []) + + def test_duplicate_identity_refuses(self): + duplicate_core = self.core() + duplicate_core["targets"].append(copy.deepcopy(duplicate_core["targets"][0])) + with self.assertRaises(ValueError): + inventory_sha256(duplicate_core) + + def test_canonical_vector_0(self): + case = self.vectors["cases"][0] + self.assertEqual(inventory_sha256(case["core"]), '4a469c57ba103d8937795c709b59765a689ae24f92b6ee1d55ddc74037b849e6') + + def test_canonical_vector_1(self): + case = self.vectors["cases"][1] + self.assertEqual(inventory_sha256(case["core"]), '4a469c57ba103d8937795c709b59765a689ae24f92b6ee1d55ddc74037b849e6') + + def test_canonical_vector_2(self): + case = self.vectors["cases"][2] + self.assertEqual(inventory_sha256(case["core"]), 'c507727b90f939d5aad3a4eff41868ab84c8cb6bcb972b3c76be3ea00186fa8a') + + def test_canonical_vector_3(self): + case = self.vectors["cases"][3] + self.assertEqual(inventory_sha256(case["core"]), '5ff478abe3a20e67de8ec879e8a91930256dab1a68c8ea04263bc1296c59c4f3') + + def test_canonical_vector_4(self): + case = self.vectors["cases"][4] + self.assertEqual(inventory_sha256(case["core"]), 'ed156dc4afac2484f25ef5ec797258d72295a787f9fb642b913fa7854a34152e') + + def test_canonical_vector_5(self): + case = self.vectors["cases"][5] + self.assertEqual(inventory_sha256(case["core"]), '01127aa13ad6f9e145489e5ceaff15426926637de8245e98b11e8953de6820dd') + + def test_canonical_vector_6(self): + case = self.vectors["cases"][6] + self.assertEqual(inventory_sha256(case["core"]), '1e79cef0d148509119876ed49ab75d86bee2e0640b31be80e74ca2ef38a4cfc6') + + def test_canonical_vector_7(self): + case = self.vectors["cases"][7] + self.assertEqual(inventory_sha256(case["core"]), '364dc7d33c64bc68faf197b77e1abbdd8cd4ea0472c44f67712d5dd58a9dadb1') + + def test_canonical_vector_8(self): + case = self.vectors["cases"][8] + self.assertEqual(inventory_sha256(case["core"]), 'ebf1d7f9ed021c8724d19f4320f2f271fbd77bc490f68720fb3ab11817e8fbed') + + def test_fixture_preimages_are_independent(self): + self.assertEqual(len(self.vectors["cases"]), 9) + for case in self.vectors["cases"]: + with self.subTest(case=case["id"]): + raw = case["canonical_ascii_preimage"].encode("ascii") + self.assertEqual(wire(case["core"]), raw) + self.assertEqual(hashlib.sha256(raw).hexdigest(), case["sha256"]) + + self.assert_held_profile(self.profile) + oracles = self.profile["origin_commit_oracles"] + self.assertNotEqual(oracles[0]["commit"], oracles[1]["commit"]) + self.assertNotEqual(oracles[0]["canonical_ascii_preimage"], oracles[1]["canonical_ascii_preimage"]) + for oracle in oracles: + raw = oracle["canonical_ascii_preimage"].encode("ascii") + self.assertEqual(len(raw), oracle["bytes"]) + self.assertEqual(hashlib.sha256(raw).hexdigest(), oracle["sha256"]) + + def test_request_decode_roundtrip(self): + expected = self.request() + self.assertEqual(decode_request(wire(expected)), expected) + + def test_request_key_exact_domain_formula(self): + self.assertEqual(request_key(self.request()), 'ac1cffe262a84ab7fb9ee3eece0d93b2a3e0b89b00a7ff1c9d747b9aa5abbd8d') + + def test_request_key_changes_each_source_identity(self): + baseline = request_key(self.request()) + self.assertEqual(baseline, 'ac1cffe262a84ab7fb9ee3eece0d93b2a3e0b89b00a7ff1c9d747b9aa5abbd8d') + for field in ["base", "head", "checked_merge", "control"]: + changed = self.request() + changed[field]["commit"] = "e" * 40 + if field == "base": + changed["checked_merge_parents"][0] = "e" * 40 + if field == "head": + changed["checked_merge_parents"][1] = "e" * 40 + with self.subTest(field=field): + self.assertNotEqual(request_key(changed), baseline) + changed = self.request() + changed["policy_sha256"] = "f" * 64 + self.assertNotEqual(request_key(changed), baseline) + + def test_request_key_refuses_acquisition_fields(self): + context = self.request() + context["acquisition_id"] = "fixture-acquisition" + with self.assertRaises(ValueError): + request_key(context) + + def test_request_refuses_duplicate_top_key(self): + raw = wire(self.request()).replace(b'"schema_version":1', b'"schema_version":1,"schema_version":1') + with self.assertRaisesRegex(ValueError, "(?i)duplicat"): + decode_request(raw) + + def test_request_refuses_duplicate_nested_key(self): + raw = wire(self.request()).replace(b'"base":{', b'"base":{"commit":"'+b'1'*40+b'",', 1) + with self.assertRaisesRegex(ValueError, '(?i)duplicat'): + decode_request(raw) + + def test_request_refuses_trailing_value(self): + raw = wire(self.request()) + b' {}' + with self.assertRaisesRegex(ValueError, '(?i)(trailing|extra data)'): + decode_request(raw) + + def test_request_refuses_nonfinite_nan(self): + raw = wire(self.request()).replace(b'"schema_version":1', b'"schema_version":NaN') + with self.assertRaisesRegex(ValueError, '(?i)(finite|nan|infinity)'): + decode_request(raw) + + def test_request_refuses_nonfinite_infinity(self): + raw = wire(self.request()).replace(b'"schema_version":1', b'"schema_version":Infinity') + with self.assertRaisesRegex(ValueError, '(?i)(finite|nan|infinity)'): + decode_request(raw) + + overflow = wire(self.request()).replace(b'"schema_version":1', b'"schema_version":1e999') + with self.assertRaisesRegex(ValueError, '(?i)(finite|nan|infinity)'): + decode_request(overflow) + + def test_request_refuses_nonfinite_negative_infinity(self): + raw = wire(self.request()).replace(b'"schema_version":1', b'"schema_version":-Infinity') + with self.assertRaisesRegex(ValueError, '(?i)(finite|nan|infinity)'): + decode_request(raw) + + def test_request_refuses_invalid_utf8(self): + raw = b'\xff' + with self.assertRaises(ValueError): + decode_request(raw) + + def test_request_refuses_bom(self): + raw = b'\xef\xbb\xbf' + wire(self.request()) + with self.assertRaises(ValueError): + decode_request(raw) + + def test_request_refuses_depth_over_64(self): + raw = b'[' * 65 + b'0' + b']' * 65 + with self.assertRaisesRegex(ValueError, '(?i)depth'): + decode_request(raw) + + def test_request_refuses_oversize(self): + raw = wire(self.request()) + b' ' * (16 * 1024 * 1024 + 1) + with self.assertRaisesRegex(ValueError, '(?i)(size|limit|large)'): + decode_request(raw) + + def test_request_refuses_wrong_root_type(self): + raw = b'[]' + with self.assertRaises(ValueError): + decode_request(raw) + + def test_request_refuses_raw_str(self): + raw = '{}' + with self.assertRaises(ValueError): + decode_request(raw) + + def test_request_refuses_raw_bytearray(self): + raw = bytearray(b'{}') + with self.assertRaises(ValueError): + decode_request(raw) + + def test_request_refuses_boolean_version(self): + context = self.request() + context['schema_version'] = True + with self.assertRaises(ValueError): + decode_request(wire(context)) + + def test_request_refuses_boolean_native_id(self): + context = self.request() + context['pull_request'] = True + with self.assertRaises(ValueError): + decode_request(wire(context)) + + def test_request_refuses_integer_native_id(self): + context = self.request() + context['pull_request'] = 17 + with self.assertRaises(ValueError): + decode_request(wire(context)) + + def test_request_refuses_noncanonical_native_id(self): + context = self.request() + context['pull_request'] = '017' + with self.assertRaises(ValueError): + decode_request(wire(context)) + + def test_request_refuses_uppercase_digest(self): + context = self.request() + context['policy_sha256'] = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' + with self.assertRaises(ValueError): + decode_request(wire(context)) + + def test_request_refuses_head_fallback(self): + context = self.request() + context['merge_mode'] = 'head_only' + with self.assertRaises(ValueError): + decode_request(wire(context)) + + def test_request_refuses_supplied_url(self): + context = self.request() + context['repository'] = 'https://fixture.invalid/repo' + with self.assertRaises(ValueError): + decode_request(wire(context)) + + def test_request_refuses_missing_and_extra_fields(self): + for field in self.request(): + context = self.request() + del context[field] + with self.subTest(missing=field), self.assertRaises(ValueError): + decode_request(wire(context)) + context = self.request() + context["unknown"] = None + with self.assertRaises(ValueError): + decode_request(wire(context)) + + def test_request_refuses_wrong_merge_parents(self): + context = self.request() + context["checked_merge_parents"] = [context["head"]["commit"], context["base"]["commit"]] + with self.assertRaises(ValueError): + decode_request(wire(context)) + + def test_request_commit_refs_are_closed(self): + for field in ["base", "head", "checked_merge", "control"]: + for key in ["repository", "commit", "tree"]: + context = self.request() + del context[field][key] + with self.subTest(field=field, key=key), self.assertRaises(ValueError): + decode_request(wire(context)) + + def test_policy_decode_uses_exact_raw_pin(self): + expected = self.policy() + raw = wire(expected) + self.assertEqual(decode_policy(raw, hashlib.sha256(raw).hexdigest()), expected) + + def test_policy_wrong_raw_pin_refuses(self): + raw = wire(self.policy()) + with self.assertRaises(ValueError): + decode_policy(raw, "0" * 64) + + def test_policy_whitespace_is_part_of_raw_pin(self): + raw = wire(self.policy()) + with self.assertRaises(ValueError): + decode_policy(raw + b"\n", hashlib.sha256(raw).hexdigest()) + + def test_policy_closed_field_set(self): + for field in self.policy(): + policy = self.policy() + del policy[field] + raw = wire(policy) + with self.subTest(field=field), self.assertRaises(ValueError): + decode_policy(raw, hashlib.sha256(raw).hexdigest()) + + for example in self.profile["policy_closed_object_examples"]: + original = self.policy() + at = original + for part in example["path"]: + at = at[part] + for field in list(at): + broken = copy.deepcopy(original) + node = broken + for part in example["path"]: + node = node[part] + del node[field] + raw = wire(broken) + with self.subTest(type=example["type"], missing=field), self.assertRaises(ValueError): + decode_policy(raw, hashlib.sha256(raw).hexdigest()) + at["unadmitted"] = None + raw = wire(original) + with self.subTest(type=example["type"], extra=True), self.assertRaises(ValueError): + decode_policy(raw, hashlib.sha256(raw).hexdigest()) + + def test_policy_refuses_duplicate(self): + raw = wire(self.policy()).replace(b'"schema_version":1', b'"schema_version":1,"schema_version":1') + with self.assertRaisesRegex(ValueError, "(?i)duplicat"): + decode_policy(raw, hashlib.sha256(raw).hexdigest()) + + def test_policy_refuses_trailing(self): + raw = wire(self.policy()) + b' {}' + with self.assertRaisesRegex(ValueError, '(?i)(trailing|extra data)'): + decode_policy(raw, hashlib.sha256(raw).hexdigest()) + + def test_policy_refuses_nonfinite(self): + raw = wire(self.policy()).replace(b'"schema_version":1', b'"schema_version":NaN') + with self.assertRaisesRegex(ValueError, '(?i)(finite|nan|infinity)'): + decode_policy(raw, hashlib.sha256(raw).hexdigest()) + + def test_policy_refuses_depth(self): + raw = b'[' * 65 + b'0' + b']' * 65 + with self.assertRaisesRegex(ValueError, '(?i)depth'): + decode_policy(raw, hashlib.sha256(raw).hexdigest()) + + def test_policy_refuses_oversize(self): + raw = wire(self.policy()) + b' ' * (16 * 1024 * 1024 + 1) + with self.assertRaisesRegex(ValueError, '(?i)(size|limit|large)'): + decode_policy(raw, hashlib.sha256(raw).hexdigest()) + + def test_policy_boolean_version_refuses(self): + policy = self.policy() + policy["schema_version"] = True + raw = wire(policy) + with self.assertRaises(ValueError): + decode_policy(raw, hashlib.sha256(raw).hexdigest()) + + def test_inventory_root_is_closed(self): + for field in ["domain", "domain_id", "targets"]: + self.reject_core([field], delete=True) + self.reject_core(["extra"], "value") + + def test_inventory_root_types_and_domain(self): + for path, value in [(["domain"], "wrong/v1"), (["domain_id"], ""), (["targets"], []), (["targets"], {}), (["targets"], True)]: + with self.subTest(path=path, value=value): + self.reject_core(path, value) + + def test_all_thirteen_target_fields_are_required(self): + fields = ['format', 'native_repository', 'package', 'target', 'module_content_identity', 'type_content_sha256', 'type_content_bytes', 'compiler_dependency_options_identity', 'accepted_formal_statement_selector', 'accepted_formal_proof_selector', 'manifest_contract_sha256', 'scope_content_identity', 'unresolved_fields'] + self.assertEqual(len(fields), 13) + for field in fields: + with self.subTest(field=field): + self.reject_core(["targets", 0, field], delete=True) + + def test_target_unknown_field_refuses(self): + self.reject_core(["targets", 0, "native_context"], {"run_id": "101"}) + + def test_exact_integer_excludes_boolean(self): + for path in [["targets", 0, "type_content_bytes"], ["targets", 0, "module_content_identity", "bytes"], ["targets", 0, "accepted_formal_proof_selector", 0, "selector", "start_byte"], ["targets", 0, "compiler_dependency_options_identity", "compiler_identity", "executable", "bytes"]]: + with self.subTest(path=path): + self.reject_core(path, True) + + def test_negative_or_fractional_sizes_refuse(self): + for value in [-1, 1.5, "14"]: + with self.subTest(value=value): + self.reject_core(["targets", 0, "type_content_bytes"], value) + + def test_package_identity_closed_and_safe(self): + self.reject_core(["targets", 0, "package", "manifest_path"], "../manifest.json") + self.reject_core(["targets", 0, "package", "extra"], None) + self.reject_core(["targets", 0, "package", "declared_name"], delete=True) + + def test_native_format_is_supported(self): + self.reject_core(["targets", 0, "format"], "unknown-native/v99") + + def test_snapshot_source_has_exact_six_content_fields(self): + for field in ["kind", "repository", "path", "git_blob", "sha256", "bytes"]: + with self.subTest(field=field): + self.reject_core(["targets", 0, "module_content_identity", field], delete=True) + self.reject_core(["targets", 0, "module_content_identity", "commit"], "1" * 40) + + def test_source_paths_refuse_escape_absolute_and_url(self): + for value in ["../Demo.lean", "/tmp/Demo.lean", "formal//Demo.lean", "formal/./Demo.lean", "https://fixture.invalid/Demo.lean", "formal\\Demo.lean"]: + with self.subTest(path=value): + self.reject_core(["targets", 0, "module_content_identity", "path"], value) + + def test_source_hashes_are_canonical(self): + for field, value in [("git_blob", "A" * 40), ("git_blob", "1" * 39), ("sha256", "A" * 64), ("sha256", "1" * 63)]: + with self.subTest(field=field, value=value): + self.reject_core(["targets", 0, "module_content_identity", field], value) + + def test_origin_requires_all_six_full_ref_fields(self): + core = self.core() + snapshot = core["targets"][0]["module_content_identity"] + ref = {key: value for key, value in snapshot.items() if key != "kind"} + ref["commit"] = "1" * 40 + for field in ["repository", "commit", "path", "git_blob", "sha256", "bytes"]: + broken = copy.deepcopy(core) + origin = {"kind": "origin", "ref": copy.deepcopy(ref)} + del origin["ref"][field] + broken["targets"][0]["module_content_identity"] = origin + with self.subTest(field=field), self.assertRaises(ValueError): + inventory_sha256(broken) + + def test_compiler_dependency_content_closed(self): + fields = ["toolchain", "compiler_identity", "options", "print_options", "dependency_lock", "dependencies", "producer_sources", "build_config", "runtime_identity"] + for field in fields: + with self.subTest(field=field): + self.reject_core(["targets", 0, "compiler_dependency_options_identity", field], delete=True) + self.reject_core(["targets", 0, "compiler_dependency_options_identity", "extra"], None) + + def test_compiler_binary_and_version_content_closed(self): + for role in ["executable", "version_output"]: + for field in ["bytes", "sha256"]: + with self.subTest(role=role, field=field): + self.reject_core(["targets", 0, "compiler_dependency_options_identity", "compiler_identity", role, field], delete=True) + + def test_options_remain_ordered_strings(self): + for field in ["options", "print_options"]: + self.reject_core(["targets", 0, "compiler_dependency_options_identity", field], [True]) + self.reject_core(["targets", 0, "compiler_dependency_options_identity", field], "pp.explicit=true") + + def test_dependency_names_unique_and_revisions_full(self): + dependency = copy.deepcopy(self.core()["targets"][0]["compiler_dependency_options_identity"]["dependencies"][0]) + self.reject_core(["targets", 0, "compiler_dependency_options_identity", "dependencies"], [dependency, dependency]) + self.reject_core(["targets", 0, "compiler_dependency_options_identity", "dependencies", 0, "revision"], "a" * 39) + self.reject_core(["targets", 0, "compiler_dependency_options_identity", "dependencies", 0, "extra"], None) + + def test_runtime_identity_closed(self): + for field in ["platform", "image_manifest", "executables"]: + with self.subTest(field=field): + self.reject_core(["targets", 0, "compiler_dependency_options_identity", "runtime_identity", field], delete=True) + self.reject_core(["targets", 0, "compiler_dependency_options_identity", "runtime_identity", "executables"], []) + + def test_runtime_executable_names_unique(self): + executables = self.core()["targets"][0]["compiler_dependency_options_identity"]["runtime_identity"]["executables"] + self.reject_core(["targets", 0, "compiler_dependency_options_identity", "runtime_identity", "executables"], executables * 2) + + def test_scope_and_import_sets_closed(self): + self.reject_core(["targets", 0, "scope_content_identity", "scope_files"], []) + self.reject_core(["targets", 0, "scope_content_identity", "import_files"], delete=True) + self.reject_core(["targets", 0, "scope_content_identity", "scope_files"], delete=True) + self.reject_core(["targets", 0, "scope_content_identity", "extra"], None) + + def test_duplicate_source_role_paths_refuse(self): + scope = self.core()["targets"][0]["scope_content_identity"]["scope_files"] + self.reject_core(["targets", 0, "scope_content_identity", "scope_files"], scope * 2) + + def test_selector_entry_and_slice_closed(self): + for array in ["accepted_formal_statement_selector", "accepted_formal_proof_selector"]: + for field in ["link_id", "selector"]: + with self.subTest(array=array, field=field): + self.reject_core(["targets", 0, array, 0, field], delete=True) + for field in ["source", "start_byte", "end_byte", "sha256"]: + with self.subTest(array=array, field=field): + self.reject_core(["targets", 0, array, 0, "selector", field], delete=True) + + def test_selector_bounds_are_exact(self): + for field, value in [("start_byte", -1), ("start_byte", 35), ("end_byte", 25), ("end_byte", 37), ("end_byte", True)]: + with self.subTest(field=field, value=value): + self.reject_core(["targets", 0, "accepted_formal_proof_selector", 0, "selector", field], value) + + def test_selector_link_sets_complete_and_unique(self): + self.reject_core(["targets", 0, "accepted_formal_statement_selector"], []) + entry = self.core()["targets"][0]["accepted_formal_proof_selector"][0] + self.reject_core(["targets", 0, "accepted_formal_proof_selector"], [entry, entry]) + self.reject_core(["targets", 0, "accepted_formal_proof_selector", 0, "link_id"], "foreign-link") + + def test_unresolved_names_are_exact_sorted_unique(self): + for value in [["not_a_field"], ["type_content_sha256", "type_content_bytes"], ["type_content_bytes", "type_content_bytes"]]: + with self.subTest(value=value): + self.reject_core(["targets", 0, "unresolved_fields"], value) + + def test_required_type_null_pair_cannot_be_half_known(self): + self.reject_core(["targets", 0, "type_content_sha256"], None) + self.reject_core(["targets", 0, "type_content_bytes"], None) + + def test_required_null_needs_exact_unresolved_name(self): + self.reject_core(["targets", 0, "scope_content_identity"], None) + self.reject_core(["targets", 0, "compiler_dependency_options_identity"], None) + + def test_collection_refuses_unknown_enumeration(self): + self.collection_refusal(lambda p: p["membership"].update(enumeration="unknown"), 'NATIVE_ENUMERATION_UNRESOLVED') + + def test_collection_refuses_ambiguous_enumeration(self): + self.collection_refusal(lambda p: p["membership"].update(enumeration="ambiguous"), 'NATIVE_ENUMERATION_UNRESOLVED') + + def test_collection_refuses_missing_enumeration(self): + self.collection_refusal(lambda p: p["membership"].pop("native_targets"), 'NATIVE_ENUMERATION_UNRESOLVED') + + def test_collection_refuses_unsupported_native_format(self): + self.collection_refusal(lambda p: p["membership"].update(native_format="unknown/v99"), 'NATIVE_FORMAT_UNSUPPORTED') + + for example in self.profile["wire_negative_examples"]: + with self.subTest(example=example["id"]): + self.collection_refusal(lambda p, e=example: self.mutate_path(p, e["path"], copy.deepcopy(e["value"])), example["reason"]) + for example in self.profile["native_wire_negative_examples"]: + with self.subTest(raw_native=example["id"]): + self.collection_refusal(lambda p, e=example: self.mutate_native_manifest_wire(p, e["path"], e["value"]), "WIRE_PROFILE_INVALID") + self.collection_refusal(self.mutate_raw_observation_wire, "WIRE_PROFILE_INVALID") + + def test_collection_refuses_omitted_native_target(self): + self.collection_refusal(lambda p: p["membership"]["native_targets"].append("Demo.uncollected"), 'NATIVE_TARGET_SET_MISMATCH') + + self.collection_refusal(lambda p: p["records"].pop(), "NATIVE_TARGET_SET_MISMATCH") + self.collection_refusal(lambda p: p["membership"]["native_targets"].pop(), "NATIVE_TARGET_SET_MISMATCH") + + def test_collection_refuses_foreign_native_target(self): + self.collection_refusal(lambda p: p["records"][0].update(target="Foreign.t"), 'NATIVE_TARGET_SET_MISMATCH') + + def test_collection_refuses_duplicate_native_record(self): + self.collection_refusal(lambda p: p["records"].append(copy.deepcopy(p["records"][0])), 'DUPLICATE_TARGET_IDENTITY') + + def test_collection_refuses_omitted_dependency(self): + self.collection_refusal(lambda p: p["records"][0]["compiler_context"].update(dependency_revisions=[]), 'DEPENDENCY_SET_MISMATCH') + + self.collection_refusal(lambda p: p["membership"].update(native_dependencies=[]), "DEPENDENCY_SET_MISMATCH") + + def test_collection_refuses_omitted_scope_role(self): + self.collection_refusal(lambda p: p["membership"]["role_inputs"].pop("scope_files"), 'SOURCE_ROLE_ENUMERATION_UNRESOLVED') + + def test_collection_refuses_omitted_import_role(self): + self.collection_refusal(lambda p: p["membership"]["role_inputs"].pop("import_files"), 'SOURCE_ROLE_ENUMERATION_UNRESOLVED') + + def test_collection_refuses_omitted_build_role(self): + self.collection_refusal(lambda p: p["membership"]["role_inputs"].pop("build_config"), 'SOURCE_ROLE_ENUMERATION_UNRESOLVED') + + def test_collection_refuses_omitted_producer_role(self): + self.collection_refusal(lambda p: p["membership"]["role_inputs"].pop("producer_sources"), 'SOURCE_ROLE_ENUMERATION_UNRESOLVED') + + def test_collection_refuses_unknown_selector_acceptance(self): + self.collection_refusal(lambda p: p["acceptances"].pop("links"), 'SELECTOR_ACCEPTANCE_UNRESOLVED') + + def test_collection_refuses_foreign_selector_link(self): + self.collection_refusal(lambda p: p["acceptances"]["links"][0].update(target="Foreign.t"), 'SELECTOR_LINK_SET_MISMATCH') + + def test_collection_refuses_origin_relabelled_snapshot(self): + self.collection_refusal(lambda p: next(row for row in p["membership"]["sources"] if row["role"] == "informal_origin").update(side="candidate"), 'SOURCE_ROLE_MISMATCH') + + def test_collection_refuses_snapshot_source_wrong_commit(self): + self.collection_refusal(lambda p: p["records"][0]["module_ref"].update(commit="9" * 40), 'SOURCE_MEMBERSHIP_MISMATCH') + + self.collection_refusal(lambda p: p["membership"]["role_inputs"]["scope_files"][0].update(commit=p["request"]["base"]["commit"]), "SOURCE_MEMBERSHIP_MISMATCH") + def crossed_snapshot(p): + p["membership"]["snapshot"] = copy.deepcopy(p["request"]["base"]) + self.collection_refusal(crossed_snapshot, "SOURCE_MEMBERSHIP_MISMATCH") + + def test_collection_refuses_raw_source_digest_mismatch(self): + self.collection_refusal(lambda p: p["membership"]["sources"][0].update(raw_base64="Zm9yZ2Vk"), 'SOURCE_BYTES_MISMATCH') + + self.assert_collection_baseline(self.collection()) + def two_failures(p): + p["membership"]["sources"][0]["raw_base64"] = "Zm9yZ2Vk" + p["acceptances"]["links"][0]["formal_proof_selector"]["sha256"] = "0" * 64 + result = self.collection(two_failures) + self.assertIsNone(result["formal_inventory_sha256"]) + self.assertEqual(result["issues"], sorted(set(result["issues"]))) + for reason in ["SOURCE_BYTES_MISMATCH", "SELECTOR_BYTES_MISMATCH", "SYNTHETIC_AUTHORITY_UNQUALIFIED", "TYPE_RECORD_UNAVAILABLE"]: + self.assertIn(reason, result["issues"]) + + def test_collection_unknown_enumeration_has_no_core(self): + result = self.collection(lambda p: p["membership"].update(enumeration="unknown")) + self.assertIsNone(result["core"]) + self.assertIsNone(result["formal_inventory_sha256"]) + self.assertIsNone(result["diagnostic_inventory_sha256"]) + self.assertIn("NATIVE_ENUMERATION_UNRESOLVED", result["issues"]) + + + def test_nested_compiler_runtime_and_selector_extra_fields_refuse(self): + for path in [["compiler_dependency_options_identity", "compiler_identity"], ["compiler_dependency_options_identity", "compiler_identity", "executable"], ["compiler_dependency_options_identity", "compiler_identity", "version_output"], ["compiler_dependency_options_identity", "runtime_identity"], ["compiler_dependency_options_identity", "runtime_identity", "executables", 0], ["compiler_dependency_options_identity", "runtime_identity", "executables", 0, "content"], ["accepted_formal_statement_selector", 0], ["accepted_formal_statement_selector", 0, "selector"], ["accepted_formal_proof_selector", 0, "selector"]]: + with self.subTest(path=path): + self.reject_core(["targets", 0] + path + ["extra"], "unadmitted") + + + def test_source_role_lists_have_unique_canonical_identity(self): + source = self.core()["targets"][0]["module_content_identity"] + for path in [["compiler_dependency_options_identity", "build_config"], ["compiler_dependency_options_identity", "producer_sources"], ["scope_content_identity", "import_files"]]: + with self.subTest(path=path): + self.reject_core(["targets", 0] + path, [source, source]) + + + def test_repeated_source_roles_cannot_disagree(self): + source = copy.deepcopy(self.core()["targets"][0]["module_content_identity"]) + source["sha256"] = "0" * 64 + self.reject_core(["targets", 0, "scope_content_identity", "import_files"], [source]) + + + def test_import_set_excludes_target_module(self): + source = copy.deepcopy(self.core()["targets"][0]["module_content_identity"]) + self.reject_core(["targets", 0, "scope_content_identity", "import_files"], [source]) + + + def test_semantic_options_order_changes_digest(self): + core = self.core() + core["targets"][0]['compiler_dependency_options_identity']['options'] = ['first=1', 'second=2'] + self.assertEqual(inventory_sha256(core), '219b9a536edc8447353206a5b4ccece855746c741e2f65dfecf070718854e4e1') + core["targets"][0]['compiler_dependency_options_identity']['options'] = ['second=2', 'first=1'] + self.assertEqual(inventory_sha256(core), '94a083534fc885a6d94ca22880a5fd760c5e28533ef6e864d13e7bb445f6c88d') + + original = self.collection() + self.assert_collection_baseline(original) + changed = self.collection(lambda p: self.reverse_effective_options(p, "options")) + self.assertEqual(changed["core"]["targets"][0]["compiler_dependency_options_identity"]["options"], list(reversed(self.profile["membership"]["producer_observation"]["options"]))) + self.assertNotEqual(changed["diagnostic_inventory_sha256"], original["diagnostic_inventory_sha256"]) + self.assertEqual(changed["diagnostic_inventory_sha256"], self.profile["projection_order_oracles"]["options"]["sha256"]) + self.assertEqual(wire(changed["core"]), self.profile["projection_order_oracles"]["options"]["canonical_ascii_preimage"].encode("ascii")) + self.assertIsNone(changed["formal_inventory_sha256"]) + + + def test_print_options_order_changes_digest(self): + core = self.core() + core["targets"][0]['compiler_dependency_options_identity']['print_options'] = ['pp.explicit=true', 'pp.universes=true'] + self.assertEqual(inventory_sha256(core), '949c0173ab4ac0fef66a8f04de8c2323cafa4453d8dbbfd7ffd512119ddda5c1') + core["targets"][0]['compiler_dependency_options_identity']['print_options'] = ['pp.universes=true', 'pp.explicit=true'] + self.assertEqual(inventory_sha256(core), '952e41e8e233ea47b2d4414346ecac97cac1fa8a48485ccef8e7ae7966278249') + + original = self.collection() + self.assert_collection_baseline(original) + changed = self.collection(lambda p: self.reverse_effective_options(p, "print_options")) + self.assertEqual(changed["core"]["targets"][0]["compiler_dependency_options_identity"]["print_options"], list(reversed(self.profile["membership"]["producer_observation"]["print_options"]))) + self.assertNotEqual(changed["diagnostic_inventory_sha256"], original["diagnostic_inventory_sha256"]) + self.assertEqual(changed["diagnostic_inventory_sha256"], self.profile["projection_order_oracles"]["print_options"]["sha256"]) + self.assertEqual(wire(changed["core"]), self.profile["projection_order_oracles"]["print_options"]["canonical_ascii_preimage"].encode("ascii")) + self.assertIsNone(changed["formal_inventory_sha256"]) + + + def test_origin_commit_remains_in_content_digest(self): + core = self.core() + core["targets"][0]["compiler_dependency_options_identity"]["producer_sources"] = [{'kind': 'origin', 'ref': {'repository': 'fixture/control', 'commit': '7777777777777777777777777777777777777777', 'path': 'control/producer.py', 'git_blob': '6666666666666666666666666666666666666666', 'sha256': '7777777777777777777777777777777777777777777777777777777777777777', 'bytes': 1}}] + self.assertEqual(inventory_sha256(core), 'ec5c0464eb3b3ac437c8309d5a9b182530eae67547689a5c05579281268d136d') + first_core = copy.deepcopy(core) + core["targets"][0]["compiler_dependency_options_identity"]["producer_sources"][0]["ref"]["commit"] = "8" * 40 + self.assertNotEqual(first_core, core) + self.assertNotEqual(wire(first_core), wire(core)) + self.assertEqual(first_core["targets"][0]["compiler_dependency_options_identity"]["producer_sources"][0]["ref"]["commit"], "7" * 40) + self.assertEqual(core["targets"][0]["compiler_dependency_options_identity"]["producer_sources"][0]["ref"]["commit"], "8" * 40) + self.assertEqual(inventory_sha256(core), 'c0df40e646762921112000930d9dae597ef08bd8e03f361dd9f0a6de5b34fe99') + + + def test_null_and_empty_selectors_are_distinct(self): + known_absent = self.core() + known_absent["targets"][0]["accepted_formal_proof_selector"][0]["selector"] = None + self.assertEqual(inventory_sha256(self.core()), BASELINE) + self.assertNotEqual(inventory_sha256(known_absent), BASELINE) + self.reject_core(["targets", 0, "accepted_formal_proof_selector"], []) + + + def test_conflicting_duplicate_target_identity_refuses(self): + core = self.core() + other = copy.deepcopy(core["targets"][0]) + other["type_content_sha256"] = "0" * 64 + core["targets"].append(other) + with self.assertRaises(ValueError): + inventory_sha256(core) + + + def test_native_identity_cannot_be_unresolved(self): + for field, value in [("format", None), ("native_repository", ""), ("target", ""), ("package", None)]: + with self.subTest(field=field): + self.reject_core(["targets", 0, field], value) + + + def test_runtime_executable_is_complete_nonempty_named_content(self): + for path, value in [(["executables", 0, "name"], ""), (["executables", 0, "content"], None), (["platform"], "")]: + with self.subTest(path=path): + self.reject_core(["targets", 0, "compiler_dependency_options_identity", "runtime_identity"] + path, value) + + + def test_scope_and_import_role_values_are_arrays(self): + for field in ["scope_files", "import_files"]: + for value in [None, {}, True]: + with self.subTest(field=field, value=value): + self.reject_core(["targets", 0, "scope_content_identity", field], value) + + + def test_policy_refuses_extra_field(self): + policy = self.policy() + policy["unknown"] = None + raw = wire(policy) + with self.assertRaises(ValueError): + decode_policy(raw, hashlib.sha256(raw).hexdigest()) + + + def test_request_commit_and_tree_are_full_lowercase_hashes(self): + for field in ["base", "head", "checked_merge", "control"]: + for key in ["commit", "tree"]: + for value in ["A" * 40, "1" * 39, True]: + context = self.request() + context[field][key] = value + with self.subTest(field=field, key=key, value=value), self.assertRaises(ValueError): + decode_request(wire(context)) + + + def test_collection_refuses_selector_raw_slice_mismatch(self): + self.collection_refusal(lambda p: p["acceptances"]["links"][0]["formal_proof_selector"].update(sha256="0" * 64), "SELECTOR_BYTES_MISMATCH") + + + def test_collection_nonimage_null_does_not_admit_image_runtime(self): + self.collection_refusal(lambda p: p["membership"].update(runtime_kind="image"), "RUNTIME_IDENTITY_UNRESOLVED") + + + def test_collection_zero_links_is_known_absence_diagnostic(self): + result = self.collection(lambda p: p["acceptances"].update(links=[])) + self.assertIsNone(result["formal_inventory_sha256"]) + self.assertIsNotNone(result["diagnostic_inventory_sha256"]) + self.assertEqual(result["core"]["targets"][0]["accepted_formal_statement_selector"], []) + self.assertEqual(result["core"]["targets"][0]["accepted_formal_proof_selector"], []) + + self.assert_collection_baseline(self.collection()) + self.assertEqual([target["target"] for target in result["core"]["targets"]], ["Demo.t", "Demo.unlinked"]) + for target in result["core"]["targets"]: + self.assertEqual(target["accepted_formal_statement_selector"], []) + self.assertEqual(target["accepted_formal_proof_selector"], []) + self.assertEqual(target["unresolved_fields"], ["type_content_bytes", "type_content_sha256"]) + + + def test_dependency_and_runtime_arrays_require_canonical_order(self): + deps = [{"name": "z", "revision": "a" * 40}, {"name": "a", "revision": "b" * 40}] + self.reject_core(["targets", 0, "compiler_dependency_options_identity", "dependencies"], deps) + exe = self.core()["targets"][0]["compiler_dependency_options_identity"]["runtime_identity"]["executables"][0] + other = copy.deepcopy(exe) + other["name"] = "a-compiler" + self.reject_core(["targets", 0, "compiler_dependency_options_identity", "runtime_identity", "executables"], [exe, other]) + + self.assert_collection_baseline(self.collection()) + projected = self.collection(self.permute_unordered_inputs) + self.assert_collection_baseline(projected) + + + def test_source_role_arrays_require_canonical_order(self): + one = copy.deepcopy(self.core()["targets"][0]["module_content_identity"]) + two = copy.deepcopy(one) + one["path"] = "z/input" + two["path"] = "a/input" + self.reject_core(["targets", 0, "compiler_dependency_options_identity", "build_config"], [one, two]) + + projected = self.collection(self.permute_unordered_inputs) + self.assertEqual(projected["core"], self.profile["expected_diagnostic_core"]) + self.assertEqual(projected["diagnostic_inventory_sha256"], self.profile["expected_diagnostic_sha256"]) + + + def test_target_array_requires_canonical_identity_order(self): + core = self.core() + other = copy.deepcopy(core["targets"][0]) + other["target"] = "A.before" + core["targets"].append(other) + with self.assertRaises(ValueError): + inventory_sha256(core) + + projected = self.collection(self.permute_unordered_inputs) + self.assertEqual([target["target"] for target in projected["core"]["targets"]], ["Demo.t", "Demo.unlinked"]) + + +if __name__ == "__main__": + unittest.main()