"""Read-only ordinary source8 gate reconciliation. Run only after the final gates, integration suites and CLI captures.

Usage: python -I -B inspect_runtime.py FULL_SOURCE_SHA PIN7 EXPECTED_NEW_COUNT
Only Git read commands are executed; Cargo, launchers and binaries are never run.
"""
from pathlib import Path
import hashlib
import io
import json
import re
import subprocess
import sys
import zipfile

if sys.flags.optimize:
    raise SystemExit('Optimized Python forbidden: verification uses assertions')
assert len(sys.argv) == 4
source, stem, expected_added = sys.argv[1], sys.argv[2], int(sys.argv[3])
assert re.fullmatch(r'[0-9a-f]{40}', source)
assert stem == source[:7]
assert 1 <= expected_added <= 100
assert expected_added == 6, 'Selected ordinary compatibility contract adds six tests'
base = Path(__file__).resolve().parents[2]
root = base / '.local/as3batch'
directory = base / '.local/ordinary-source8-gates-20260925'
prior = base / '.local/analysis-output-acceptance-gates-20260925'
destination = Path(__file__).with_name('ORDINARY-RUNTIME-READBACK.json')
assert not destination.exists(), 'Preserve prior readback; do not overwrite'
BASELINE = 'edf096cd33350865ecfc3c65ec266a6c0d3c4000'
ARCHIVE_SHA = '2f5e0c5257eba11908b60e02b76d529fcd53f11edd057c859d3cb1b34f41d7c4'
COMPONENT = '0c07f53ab517626f536f79dbaa2885a587bf1db7'
FINAL_LAUNCHER = 'c0126c93f371c6f8f2b38daace73d06e1cac741021faeff10f18d34628eca6c8'
sha = lambda raw: hashlib.sha256(raw).hexdigest()


def git(*args):
    return subprocess.check_output(['git', '--no-replace-objects', *args], cwd=root)


def within(folder, relative):
    candidate = (folder / relative).resolve()
    assert candidate.is_relative_to(folder.resolve()), relative
    return candidate


def receipt(folder, name):
    raw_receipt = (folder / (name + '.result.json')).read_bytes()
    data = json.loads(raw_receipt)
    raw = (folder / (name + '.log')).read_bytes()
    assert data['log_sha256'] == sha(raw)
    return data, raw, raw_receipt


def outcomes(raw):
    rows = re.findall(r'^test ([^\r\n]+) \.\.\. (ok|FAILED|ignored)\r?$', raw.decode(), re.M)
    assert len(rows) == len(dict(rows)), 'Duplicate runtime name'
    return rows


def members(raw):
    names = re.findall(r'^([^\r\n]+): test\r?$', raw.decode(), re.M)
    assert len(names) == len(set(names)), 'Duplicate listing name'
    return names


def failure_blocks(raw):
    # Preserve every byte of block whitespace/body except the numeric thread identifier.
    rows = re.findall(rb'^---- ([^\r\n]+) stdout ----\r?\n(.*?)(?=^---- |^failures:|\Z)',
                      raw, re.M | re.S)
    assert len(rows) == len(dict(rows)), 'Duplicate failure block'
    return {name.decode(): re.sub(rb"(?m)^(thread '[^\r\n]*') \(\d+\) panicked",
                                rb'\1 (<PID>) panicked', body) for name, body in rows}


# Anchor baseline local full/list/fmt logs AND receipts to the immutable locally committed ZIP (server publication is blocked).
archive_raw = (base / 'harness/experiments/analysis-output-acceptance-20260925/evidence.zip').read_bytes()
assert sha(archive_raw) == ARCHIVE_SHA
baseline = {}
with zipfile.ZipFile(io.BytesIO(archive_raw)) as archive:
    names = archive.namelist()
    assert len(names) == len(set(names))
    for mode in ('full', 'list', 'fmt'):
        name = f'acceptance-{mode}-edf096c-1'
        data, raw, raw_receipt = receipt(prior, name)
        assert data['source'] == data['head_after'] == BASELINE
        for suffix, content in [('.log', raw), ('.result.json', raw_receipt)]:
            matches = [n for n in names if n == name + suffix or n.endswith('/' + name + suffix)]
            assert len(matches) == 1, (name, suffix, matches)
            assert archive.read(matches[0]) == content
        baseline[mode] = (data, raw)
old, old_raw = baseline['full']
old_rows = outcomes(old_raw)
assert old_rows == [tuple(x) for x in old['outcomes']]
assert len(old_rows) == 292 and old['exit'] == 101
assert sum(v == 'ok' for _, v in old_rows) == 276
assert sum(v == 'FAILED' for _, v in old_rows) == 16
old_out = dict(old_rows)
renames = {
    'language::analysis_source::declarations::tests::inherited_version_root_and_short_word_contracts_do_not_enable_public8':
    'language::analysis_source::declarations::tests::inherited_version_root_and_short_word_contracts_do_not_enable_public_typed8',
    'language::analysis_source::tests::public_source_headers_and_existing_numeric_token_controls_are_unchanged':
    'language::analysis_source::tests::public_ordinary_source8_preserves_typed_refusal_and_numeric_controls',
}
assert set(renames) <= set(old_out) and not set(renames.values()) & set(old_out)
mapped_old = {renames.get(name, name): status for name, status in old_out.items()}
assert len(mapped_old) == len(old_out)
old_listing = members(baseline['list'][1])
assert old_listing == baseline['list'][0]['listing_members']
assert baseline['list'][0]['exit'] == 0 and set(old_listing) == set(old_out)
assert baseline['fmt'][0]['exit'] == 1

assert git('rev-parse', 'HEAD').decode().strip() == source
assert not git('status', '--porcelain', '--untracked-files=no').strip()
scope = ['Cargo.toml', 'Cargo.lock', 'rust-toolchain.toml', '.cargo', 'build', 'crates',
         'assets', 'docs', 'examples', 'harness/fixtures', 'vendor']
paths = git('ls-tree', '-r', '--name-only', source, *scope).decode().splitlines()
blobs = subprocess.check_output(['git', '--no-replace-objects', 'cat-file', '--batch'], cwd=root,
    input=''.join(f'{source}:{p}\n' for p in paths).encode())
offset, expected_inputs = 0, []
for path in paths:
    end = blobs.index(b'\n', offset)
    _, kind, count = blobs[offset:end].split()
    count = int(count)
    raw = blobs[end + 1:end + 1 + count]
    assert kind == b'blob' and within(root, path).read_bytes() == raw, path
    expected_inputs.append({'path': path, 'bytes': count, 'sha256': sha(raw)})
    offset = end + count + 2
assert offset == len(blobs)

changed_paths = git('diff', '--name-only', COMPONENT, source).decode().splitlines()
assert sorted(changed_paths) == ['crates/oa-core/tests/r3_migration.rs', 'harness/ordinary-source8-compatibility-implementation-20260925.md']
assert git('ls-tree', '-r', '--name-only', COMPONENT, *scope).decode().splitlines() == paths
component_inputs = []
for item in expected_inputs:
    if item['path'] == 'crates/oa-core/tests/r3_migration.rs':
        content = git('show', COMPONENT + ':' + item['path'])
        component_inputs.append({'path': item['path'], 'bytes': len(content), 'sha256': sha(content)})
    else:
        component_inputs.append(item)
assert [a['path'] for a, b in zip(component_inputs, expected_inputs) if a != b] == ['crates/oa-core/tests/r3_migration.rs']
assert len(expected_inputs) == 560 and len(component_inputs) == 560

prefix = ['cargo', 'test', '--locked', '--offline', '-p', 'oa-core', '--lib']
commands = {
    'focused': prefix + ['ordinary_source8', '--', '--test-threads=1'],
    'full': prefix + ['--', '--test-threads=1'],
    'list': prefix + ['--', '--list'],
    'clippy': ['cargo', 'clippy', '--locked', '--offline', '-p', 'oa-core', '--all-targets', '--', '-D', 'warnings'],
    'fmt': ['cargo', 'fmt', '--all', '--', '--check'],
}
expected_env = baseline['full'][0]['environment']
assert expected_env['CARGO_BUILD_JOBS'] == '1' and expected_env['CARGO_INCREMENTAL'] == '0'
for key in ('RUSTFLAGS', 'RUSTC', 'RUSTUP_TOOLCHAIN', 'ARCADIA_CODEC_LIFECYCLE_PHASE', 'RUST_MIN_STACK'):
    assert expected_env[key] is None
current_env = expected_env.copy()
verified, all_receipts, raw_logs = {}, {}, {}
artifact_identity = launcher_identity = None
for mode, command in commands.items():
    name = f'ordinary-{mode}-{COMPONENT[:7]}-1'
    data, raw, receipt_raw = receipt(directory, name)
    assert data['source'] == data['head_after'] == COMPONENT
    assert data['mode'] == mode and data['command'] == command
    assert data['invocation'] == 'cargo' and data['test_target'] is None
    assert data['filter'] == ('ordinary_source8' if mode == 'focused' else '')
    assert not data['changed_inputs'] and not data['verification_failures']
    assert data['cwd'] == str(root) and data['environment'] == current_env
    manifest_raw = within(directory, data['inputs']).read_bytes()
    assert sha(manifest_raw) == data['inputs_sha256']
    assert json.loads(manifest_raw) == {'source': COMPONENT, 'inputs': component_inputs}
    launcher = within(directory, data['launcher_copy']).read_bytes()
    assert sha(launcher) == data['launcher_sha256'] == data['launcher_sha256_after']
    assert COMPONENT.encode() in launcher
    if launcher_identity is None:
        launcher_identity = sha(launcher)
    assert sha(launcher) == launcher_identity, 'Unexpected mixed launchers: review explicitly'
    assert sha(launcher) == 'ba5b84b6eae0e5c24dc2eb52b4cc20b5ba648261b36fd72edddd5b2fbf791765', 'Review any final launcher successor before execution'
    rows = outcomes(raw)
    assert rows == [tuple(x) for x in data['outcomes']]
    listing = members(raw) if mode == 'list' else []
    assert listing == data['listing_members'] and len(listing) == data['listing_count']
    if mode in ('focused', 'full'):
        counts = tuple(sum(v == state for _, v in rows) for state in ('ok', 'FAILED', 'ignored'))
        summary = re.findall(r'^test result: (ok|FAILED)\. (\d+) passed; (\d+) failed; (\d+) ignored; 0 measured; (\d+) filtered out;', raw.decode(), re.M)
        assert len(summary) == 1 and tuple(map(int, summary[0][1:4])) == counts
        assert summary[0][0] == ('FAILED' if counts[1] else 'ok')
        assert int(summary[0][4]) == (291 if mode == 'focused' else 0)
    else:
        assert not rows
    assert data['exit'] == {'focused': 0, 'full': 0, 'list': 0, 'clippy': 0, 'fmt': 1}[mode]
    assert len(data['artifacts']) == (1 if mode in ('focused', 'full', 'list') else 0)
    for artifact in data['artifacts']:
        path = Path(artifact['path'])
        assert path.resolve().is_relative_to(Path(expected_env['CARGO_TARGET_DIR']).resolve())
        actual = path.read_bytes()
        assert len(actual) == artifact['bytes'] and sha(actual) == artifact['sha256']
        assert str(path).replace('\\', '/') in raw.decode().replace('\\', '/')
        if artifact_identity is None:
            artifact_identity = artifact
        assert artifact == artifact_identity, 'Test/list artifact mismatch'
    all_receipts[mode], raw_logs[mode] = data, raw
    verified[name] = {'source': COMPONENT, 'exit': data['exit'], 'outcomes': len(rows),
        'listing': len(listing), 'log_sha256': sha(raw), 'result_sha256': sha(receipt_raw),
        'inputs_sha256': sha(manifest_raw), 'launcher_sha256': sha(launcher)}

new_out = dict(all_receipts['full']['outcomes'])
assert len(new_out) == 292 + expected_added
assert not set(renames) & set(new_out), 'Old names must be replaced only by the two exact authorized names'
assert all(new_out.get(k) == 'ok' for k in mapped_old), 'Every prior mapped name must pass, including all 16 former failures'
added = set(new_out) - set(mapped_old)
assert len(added) == expected_added
assert all(new_out[k] == 'ok' and 'ordinary_source8' in k for k in added)
focused_control = 'language::analysis_source::tests::public_ordinary_source8_preserves_typed_refusal_and_numeric_controls'
assert focused_control in renames.values() and focused_control not in added
assert set(dict(all_receipts['focused']['outcomes'])) == added | {focused_control}
assert len(all_receipts['focused']['outcomes']) == 7
assert all(status == 'ok' for _, status in all_receipts['focused']['outcomes'])
assert set(all_receipts['list']['listing_members']) == set(new_out)
old_blocks = failure_blocks(old_raw)
assert len(old_blocks) == 16 and set(old_blocks) == {k for k, v in old_out.items() if v == 'FAILED'}
assert not failure_blocks(raw_logs['full'])
assert all(value == 'ok' for value in new_out.values())
assert raw_logs['fmt'] == baseline['fmt'][1]


def additional(name, mode, command, target=None, selected_filter='', *, checkpoint=COMPONENT, exit_code=0, artifact_count=1, current_artifact=True, allow_failures=False):
    data, raw, raw_receipt = receipt(directory, name)
    assert data['source'] == data['head_after'] == checkpoint
    assert data['mode'] == mode and data['command'] == command
    assert data['filter'] == selected_filter and data['test_target'] == target
    assert data['invocation'] == 'cargo' and data['cwd'] == str(root)
    assert data['environment'] == current_env and data['exit'] == exit_code
    assert not data['changed_inputs']
    assert not data['verification_failures'] or allow_failures
    manifest_raw = within(directory, data['inputs']).read_bytes()
    assert sha(manifest_raw) == data['inputs_sha256']
    assert json.loads(manifest_raw) == {'source': checkpoint, 'inputs': expected_inputs if checkpoint == source else component_inputs}
    launcher = within(directory, data['launcher_copy']).read_bytes()
    assert sha(launcher) == data['launcher_sha256'] == data['launcher_sha256_after'] == (FINAL_LAUNCHER if checkpoint == source else launcher_identity)
    assert outcomes(raw) == [tuple(x) for x in data['outcomes']]
    assert len(data['artifacts']) == artifact_count
    artifact = data['artifacts'][0] if artifact_count else None
    if artifact is not None and current_artifact:
        path = Path(artifact['path'])
        assert path.resolve().is_relative_to(Path(current_env['CARGO_TARGET_DIR']).resolve())
        actual = path.read_bytes()
        assert len(actual) == artifact['bytes'] and sha(actual) == artifact['sha256']
    verified[name] = {'result_sha256': sha(raw_receipt), 'log_sha256': sha(raw),
                      'inputs_sha256': sha(manifest_raw), 'artifact': artifact}
    return data, raw


suites = {
    'source_project': '', 'source_identity_updates': '', 'source_nested_updates': '',
    'source_files': '', 'r3_migration': '', 'review_regressions': 'checked_save_',
    'source7_contract': 'source7_source_bundle_migration_is_token_only_and_new_link_stays_with_caller',
}
integration_counts = {}
for target, selected_filter in suites.items():
    selected = {}
    for mode in ('integration-list', 'integration-suite'):
        command = ['cargo', 'test', '--locked', '--offline', '-p', 'oa-core', '--test', target]
        if selected_filter:
            command.append(selected_filter)
        command += ['--', '--list' if mode == 'integration-list' else '--test-threads=1']
        if target == 'source7_contract':
            command.append('--exact')
        checkpoint = source if target == 'r3_migration' else COMPONENT
        data, raw = additional(f'ordinary-{mode}-{target}-{checkpoint[:7]}-1', mode, command, target, selected_filter, checkpoint=checkpoint)
        assert Path(data['artifacts'][0]['path']).name.startswith(target + '-')
        running = re.findall(r'Running [^\r\n]+ \(([^\r\n]+\.exe)\)', raw.decode())
        assert len(running) == 1
        assert (root / running[0]).resolve() == Path(data['artifacts'][0]['path']).resolve()
        listed = members(raw) if mode == 'integration-list' else []
        assert data['listing_members'] == listed and data['listing_count'] == len(listed)
        if mode == 'integration-list':
            assert listed and not outcomes(raw)
        else:
            rows = outcomes(raw)
            assert rows and all(status == 'ok' for _, status in rows)
            assert not failure_blocks(raw)
            summary = re.findall(r'^test result: ok\. (\d+) passed; 0 failed; 0 ignored; 0 measured; \d+ filtered out;', raw.decode(), re.M)
            assert summary == [str(len(rows))]
        selected[mode] = data
    listing, suite = selected['integration-list'], selected['integration-suite']
    assert listing['artifacts'] == suite['artifacts']
    assert set(listing['listing_members']) == {name for name, _ in suite['outcomes']}
    if target == 'review_regressions':
        assert set(listing['listing_members']) == {
            'checked_save_returns_exact_bytes_and_accepts_unchanged_external_content',
            'checked_save_rejects_external_changes_and_preserves_their_exact_bytes',
            'checked_save_rejects_external_deletion_without_recreating_the_file'}
    if target == 'source7_contract':
        assert listing['listing_members'] == [selected_filter]
    integration_counts[target] = len(suite['outcomes'])

old_r3 = {}
for mode in ('integration-list', 'integration-suite'):
    command = ['cargo', 'test', '--locked', '--offline', '-p', 'oa-core', '--test', 'r3_migration',
               '--', '--list' if mode == 'integration-list' else '--test-threads=1']
    data, raw = additional(f'ordinary-{mode}-r3_migration-0c07f53-1', mode, command, 'r3_migration',
                           exit_code=0 if mode == 'integration-list' else 101,
                           current_artifact=False, allow_failures=mode == 'integration-suite')
    if mode == 'integration-list':
        assert len(members(raw)) == 5 and members(raw) == data['listing_members']
        assert data['listing_count'] == 5 and not outcomes(raw)
    else:
        assert data['verification_failures'] == ['Every selected integration outcome must actually pass',
                                                'Expected one complete all-passed selected integration summary']
        rows = outcomes(raw)
        assert len(rows) == 5 and sum(status == 'ok' for _, status in rows) == 4
        assert {name for name, status in rows if status == 'FAILED'} == {'frozen_v4_json_and_source_preserve_the_old_review_without_fabricating_semantics'}
        assert set(failure_blocks(raw)) == {'frozen_v4_json_and_source_preserve_the_old_review_without_fabricating_semantics'}
        assert sha(raw) == 'ee55320de5e208beb921ce219afb38db7b27c86cd64d176837c952b803a48582'
        assert re.findall(r'^test result: FAILED\. (\d+) passed; (\d+) failed; (\d+) ignored; 0 measured; (\d+) filtered out;', raw.decode(), re.M) == [('4', '1', '0', '0')]
    old_r3[mode] = data
assert old_r3['integration-list']['artifacts'] == old_r3['integration-suite']['artifacts']
assert set(old_r3['integration-list']['listing_members']) == {name for name, _ in old_r3['integration-suite']['outcomes']}
new_r3_list, _ = receipt(directory, f'ordinary-integration-list-r3_migration-{stem}-1')[:2]
assert set(new_r3_list['listing_members']) == set(old_r3['integration-list']['listing_members'])
for mode in ('clippy', 'fmt'):
    data, raw = additional(f'ordinary-{mode}-{stem}-1', mode, commands[mode], checkpoint=source,
                           exit_code=0 if mode == 'clippy' else 1, artifact_count=0)
    assert not outcomes(raw) and not data['listing_members'] and data['listing_count'] == 0
    if mode == 'fmt':
        assert raw == baseline['fmt'][1] == raw_logs['fmt']

build_command = ['cargo', 'build', '--locked', '--offline', '-p', 'oa-cli', '--bin', 'arcadia', '--message-format=json']
build, build_raw = additional(f'ordinary-cli-build-{COMPONENT[:7]}-1', 'cli-build', build_command)
assert not build['outcomes'] and build['listing_members'] == [] and build['listing_count'] == 0
emitted = []
for line in build_raw.splitlines():
    try:
        row = json.loads(line)
    except (json.JSONDecodeError, UnicodeDecodeError):
        continue
    if row.get('reason') == 'compiler-artifact' and row.get('target', {}).get('name') == 'arcadia' and row.get('executable'):
        assert row['target']['kind'] == ['bin'] and not row['profile']['test']
        emitted.append(row['executable'])
assert len(emitted) == 1 and Path(emitted[0]).resolve() == Path(build['artifacts'][0]['path']).resolve()

original = {
    'project.arcadia': '// \u96e8\r\narcadia 8;\r\nproject p "Project" id "00000000-0000-0000-0000-000000000001" {\r\ninclude "participants.arcadia"; include "children.arcadia";\r\n}\r\n',
    'participants.arcadia': '// @team remains documentation\r\noa_entity team "Team @team" id "00000000-0000-0000-0000-000000000002" {}\r\n',
    'children.arcadia': 'oa_entity child "Child" id "00000000-0000-0000-0000-000000000003" { parent @team; }\r\n',
}
expected_after = {
    'participants.arcadia': '// @team remains documentation\r\noa_entity rescue_team "Team @team" id "00000000-0000-0000-0000-000000000002" {}\r\n',
    'children.arcadia': 'oa_entity child "Child" id "00000000-0000-0000-0000-000000000003" { parent @rescue_team; }\r\n',
}
inventory = {name: {'bytes': len(text.encode()), 'sha256': sha(text.encode())} for name, text in original.items()}
fixture = directory / f'cli-fixture-{COMPONENT[:7]}'
assert sorted(p.relative_to(fixture).as_posix() for p in fixture.rglob('*')) == sorted(original)
for name, text in original.items():
    assert (fixture / name).read_bytes() == text.encode()
cli_launcher_hash = None
for operation in ('check', 'rename-alias'):
    name = f'ordinary-cli-{operation}-{COMPONENT[:7]}-1'
    record_raw = (directory / (name + '.cli.json')).read_bytes()
    data = json.loads(record_raw)
    stdout = (directory / (name + '.stdout.json')).read_bytes()
    stderr = (directory / (name + '.stderr.txt')).read_bytes()
    assert data['stdout_sha256'] == sha(stdout) and data['stderr_sha256'] == sha(stderr)
    assert data['source'] == COMPONENT and data['build_artifact'] == build['artifacts'][0]
    assert data['environment'] == current_env and data['cwd'] == str(root)
    assert data['inputs'] == build['inputs'] and data['inputs_sha256'] == build['inputs_sha256']
    assert not data['changed_inputs'] and not data['verification_failures']
    assert data['exit'] == 0 and stderr == b''
    assert data['expected_input_inventory'] == data['after_inventory'] == inventory
    entry = str(fixture / 'project.arcadia')
    command = [build['artifacts'][0]['path'], operation, entry]
    if operation == 'rename-alias':
        command += ['team', 'rescue_team']
    command.append('--json')
    assert data['argv'] == command
    launcher = within(directory, data['launcher_copy']).read_bytes()
    assert sha(launcher) == data['launcher_sha256']
    if cli_launcher_hash is None:
        cli_launcher_hash = sha(launcher)
    assert sha(launcher) == cli_launcher_hash
    assert cli_launcher_hash == '308fdd08011a57ccdf896868c6abd34d2e5c7637a95bfe0d8fccb456439dbd5d'
    report = json.loads(stdout)
    expected = {'format_version': 1, 'entry': entry, 'operation': operation,
                'status': 'checked' if operation == 'check' else 'preview',
                'exit_code': 0, 'written': False, 'diagnostics': [],
                'identities_to_stabilize': 0, 'migration': None}
    for key, value in expected.items():
        assert key in report and report[key] == value
    if operation == 'check':
        assert report['changes'] == []
    else:
        assert [r['path'] for r in report['changes']] == ['children.arcadia', 'participants.arcadia']
        for change in report['changes']:
            path = change['path']
            assert change['before'] == original[path] and change['after'] == expected_after[path]
            for marker, text in [('-', original[path]), ('+', expected_after[path])]:
                assert marker + next(line for line in text.splitlines() if line.startswith('oa_entity')) in change['diff']
    verified[name] = {'receipt_sha256': sha(record_raw), 'stdout_sha256': sha(stdout),
                      'stderr_sha256': sha(stderr), 'launcher_sha256': sha(launcher)}

# Preserve and account for the actual first failed focused run, not an invented baseline.
initial, initial_raw, initial_receipt = receipt(directory, 'ordinary-focused-33b86a4-1')
assert initial['source'] == initial['head_after'] == '33b86a4d6b4bc1b156a93ae3596fe0ad7b4dbbe5'
assert initial['exit'] == 101 and not initial['changed_inputs']
initial_rows = outcomes(initial_raw)
assert initial_rows == [tuple(row) for row in initial['outcomes']]
assert len(initial_rows) == 6 and sum(v == 'ok' for _, v in initial_rows) == 5
assert [n for n, v in initial_rows if v == 'FAILED'] == ['language::ordinary_source8::current_formatter_roundtrips_complete_ordinary_examples_and_history']
assert set(dict(initial_rows)) == added
assert initial['command'] == commands['focused'] and initial['environment'] == current_env
assert not initial['verification_failures']
initial_launcher = within(directory, initial['launcher_copy']).read_bytes()
assert sha(initial_launcher) == initial['launcher_sha256'] == initial['launcher_sha256_after'] == '6e2fad2fff3066861a42f85ab6c3ada8b4c8954075fb402e555c5f686dae840b'
initial_manifest_raw = within(directory, initial['inputs']).read_bytes()
assert sha(initial_manifest_raw) == initial['inputs_sha256']
initial_manifest = json.loads(initial_manifest_raw)
assert initial_manifest['source'] == initial['source']
initial_paths = git('ls-tree', '-r', '--name-only', initial['source'], *scope).decode().splitlines()
assert initial_paths == [item['path'] for item in initial_manifest['inputs']]
initial_blobs = subprocess.check_output(['git', '--no-replace-objects', 'cat-file', '--batch'], cwd=root,
    input=''.join(f"{initial['source']}:{p}\n" for p in initial_paths).encode())
offset = 0
for item in initial_manifest['inputs']:
    end = initial_blobs.index(b'\n', offset)
    _, kind, size = initial_blobs[offset:end].split()
    size = int(size)
    raw = initial_blobs[end + 1:end + 1 + size]
    assert kind == b'blob' and size == item['bytes'] and sha(raw) == item['sha256']
    offset = end + size + 2
assert offset == len(initial_blobs)
assert b'assertion failed: !example.traces.is_empty()' in initial_raw
initial_failure = {'source': initial['source'], 'receipt_sha256': sha(initial_receipt),
                   'log_sha256': sha(initial_raw), 'passed': 5, 'failed': 1}

intermediate_source = '520e50ce62f067dff69f03760c8b12929df9b920'
intermediate_failures = {
    *renames,
    'language::analysis_source::lower::tests::staged_oa_and_sa_lowering_match_complete_independent_17_uuid_oracles',
    'language::analysis_source::write::tests::typed_oa_sa_canonical_roundtrips_match_independent_projects',
}
intermediate = {}
intermediate_artifact = None
for mode in ('focused', 'full', 'list'):
    name = f'ordinary-{mode}-520e50c-1'
    data, raw, raw_receipt = receipt(directory, name)
    assert data['source'] == data['head_after'] == intermediate_source
    assert data['command'] == commands[mode] and data['mode'] == mode
    assert data['environment'] == current_env and data['cwd'] == str(root)
    assert not data['changed_inputs'] and not data['verification_failures']
    launcher = within(directory, data['launcher_copy']).read_bytes()
    assert sha(launcher) == data['launcher_sha256'] == data['launcher_sha256_after'] == '59104b1acd39b3981b7339e585af9bd7f9cb87865ee82ffb763f0e7ce527713c'
    manifest_raw = within(directory, data['inputs']).read_bytes()
    assert sha(manifest_raw) == data['inputs_sha256']
    manifest = json.loads(manifest_raw)
    assert manifest['source'] == intermediate_source
    historic_paths = git('ls-tree', '-r', '--name-only', intermediate_source, *scope).decode().splitlines()
    assert historic_paths == [item['path'] for item in manifest['inputs']]
    historic_blobs = subprocess.check_output(['git', '--no-replace-objects', 'cat-file', '--batch'], cwd=root,
        input=''.join(f'{intermediate_source}:{p}\n' for p in historic_paths).encode())
    offset = 0
    for item in manifest['inputs']:
        end = historic_blobs.index(b'\n', offset)
        _, kind, size = historic_blobs[offset:end].split()
        size = int(size)
        content = historic_blobs[end + 1:end + 1 + size]
        assert kind == b'blob' and size == item['bytes'] and sha(content) == item['sha256']
        offset = end + size + 2
    assert offset == len(historic_blobs)
    assert len(data['artifacts']) == 1
    if intermediate_artifact is None:
        intermediate_artifact = data['artifacts'][0]
    assert data['artifacts'] == [intermediate_artifact]
    rows = outcomes(raw)
    assert rows == [tuple(row) for row in data['outcomes']]
    if mode == 'focused':
        assert data['exit'] == 0 and dict(rows) == {name: 'ok' for name in added}
        assert re.findall(r'^test result: ok\. (\d+) passed; (\d+) failed; (\d+) ignored; 0 measured; (\d+) filtered out;', raw.decode(), re.M) == [('6', '0', '0', '292')]
    elif mode == 'full':
        assert data['exit'] == 101 and len(rows) == 298
        assert {name for name, status in rows if status == 'FAILED'} == intermediate_failures
        assert sum(status == 'ok' for _, status in rows) == 294
        assert set(dict(rows)) == set(old_out) | added
        assert all(dict(rows)[name] == 'ok' for name, status in old_out.items() if status == 'FAILED')
        assert set(failure_blocks(raw)) == intermediate_failures
        assert re.findall(r'^test result: FAILED\. (\d+) passed; (\d+) failed; (\d+) ignored; 0 measured; (\d+) filtered out;', raw.decode(), re.M) == [('294', '4', '0', '0')]
    else:
        assert data['exit'] == 0 and not rows
        assert members(raw) == data['listing_members'] and data['listing_count'] == 298
        assert set(members(raw)) == set(old_out) | added
    intermediate[name] = {'receipt_sha256': sha(raw_receipt), 'log_sha256': sha(raw),
                          'inputs_sha256': sha(manifest_raw), 'exit': data['exit']}

result = {'source': source, 'baseline': BASELINE, 'baseline_archive_sha256': ARCHIVE_SHA,
    'checker_sha256': sha(Path(__file__).read_bytes()), 'inputs': len(expected_inputs),
    'focused_passed': 7, 'focused_existing_renamed_control': focused_control,
    'prior_passes_preserved': 276, 'prior_failures_now_passed': 16, 'added_passed': expected_added, 'added_names': sorted(added),
    'full_passed': sum(v == 'ok' for v in new_out.values()), 'full_failed': 0,
    'former_failure_names': sorted(old_blocks),
    'identical_fmt_sha256': sha(raw_logs['fmt']), 'artifact': artifact_identity,
    'environment': current_env, 'baseline_environment': expected_env,
    'receipts': verified, 'integration_pass_counts': integration_counts,
    'component_source': COMPONENT, 'reused_component_inputs': len(component_inputs),
    'successor_only_declared_delta': 'crates/oa-core/tests/r3_migration.rs',
    'old_r3_recorded_artifact': old_r3['integration-suite']['artifacts'][0],
    'cli_artifact': build['artifacts'][0], 'initial_failed_run': initial_failure,
    'exact_authorized_name_mapping': renames, 'intermediate_520_records': intermediate,
    'intermediate_recorded_artifact': intermediate_artifact,
    'scope': 'Committed declared inputs, pinned baseline archive, raw logs and current artifact bytes; no Cargo/executable execution. Launcher semantics require independent source review.'}
with destination.open('x', encoding='utf-8', newline='\n') as stream:
    stream.write(json.dumps(result, indent=2) + '\n')
print(json.dumps(result, indent=2))