qishizhe/digital-drosophila
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Seal AO interface failure and verified isolated postprocessing diagnosis

Browse Source
This commit is contained in:
Digital Drosophila Archive
2026-09-30 17:57:02 +08:00
parent 4ff241bdc9
commit 8e9f8f4d56
126 changed files with 92124 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files
registry/phase4ao-conditioning-interface/source-snapshot/runtime_continuation.py
+478
View File
@@ -0,0 +1,478 @@
"""Unregistered fixed-weight continuation of the reporting-only AN executor.
run_continued(case, out, build, overlay, manifest, checkpoint_dir, mode='light')
also accepts mode='reference'. Inputs/events/counts use segment-local ticks;
summary and receipts expose global_tick_offset/global_next_tick. No training,
weight update, early stopping, or implicit extra tail is performed.
The caller must externally pin spec.parent_checkpoint_manifest_sha256. A fresh
parent's original runtime receipt did NOT bind state.npz: seal_checkpoint adds
that binding, after checking the available original receipts and current bytes.
It cannot retroactively prove that an unsealed state file was never modified.
Full graph/APL/coefficient/preregistered-input authority remains the coordinator's
responsibility, as in runtime_light. No executable/venv path is resolved here.
"""
from __future__ import annotations
import ast
import copy
import hashlib
import importlib.util
from pathlib import Path
import sys
import numpy as np
LIGHT_SHA = '522b8c31ea938890fe15364fccd25ccc5bded54101754909f255532e7ad01aae'
N = 166700
E = 25582938
MANIFEST = 'checkpoint-manifest.json'
RECEIPT = 'continuation-receipt.json'
RESTORE = '_continuation.restore(v, g, ref, counts, ring, apl_ring, apl, upload)'
CLOCK_OLD = 'tick >= 18'
CLOCK_NEW = 'tick + _continuation.global_offset >= 18'
def _light():
path = Path(__file__).resolve().parent / 'runtime_light.py'
raw = path.read_bytes()
if hashlib.sha256(raw).hexdigest() != LIGHT_SHA:
raise ValueError('Fresh runtime source pin changed')
name = 'phase4an_continuation_pinned_light'
existing = sys.modules.get(name)
if existing is not None:
if getattr(existing, '__continuation_pin__', None) != LIGHT_SHA or Path(existing.__file__).resolve() != path:
raise ValueError('Unverified runtime module binding')
return existing
spec = importlib.util.spec_from_file_location(name, path)
module = importlib.util.module_from_spec(spec)
sys.modules[name] = module
try:
exec(compile(raw, str(path), 'exec'), module.__dict__)
except BaseException:
sys.modules.pop(name, None)
raise
module.__continuation_pin__ = LIGHT_SHA
return module
R = _light() # Pure NumPy/stdlib; this does not import Torch or run a brain.
def rotate_spike_ring(raw_ring, phase_tick):
"""Parent's local next-write slot becomes the child's local slot zero."""
R.require(isinstance(raw_ring, np.ndarray) and raw_ring.dtype == np.uint8 and
raw_ring.ndim == 2 and raw_ring.shape[0] == 19, 'Invalid spike ring dtype/shape')
R.require(type(phase_tick) is int and phase_tick >= 0 and np.all(raw_ring <= 1), 'Invalid ring phase/content')
return raw_ring[(np.arange(19) + phase_tick % 19) % 19].copy()
def _tree_hashes(directory):
"""Exact regular-file inventory, no symlink/reparse escapes, no self-hash."""
directory = Path(directory).resolve(strict=True)
R.require(directory.is_dir(), 'Checkpoint must be a directory')
result = {}
for path in sorted(directory.rglob('*')):
R.require(not path.is_symlink() and path.resolve().is_relative_to(directory), 'Checkpoint contains a linked/escaping path')
if path.is_dir():
continue
R.require(path.is_file(), 'Checkpoint contains a nonregular entry')
relative = path.relative_to(directory).as_posix()
if relative == MANIFEST:
continue
R.require('error' not in path.name.lower() and 'failure' not in path.name.lower(), 'Parent has failure/error evidence')
result[relative] = R.digest(path)
return result
def _npz(path, keys):
with np.load(path, allow_pickle=False) as archive:
R.require(len(archive.files) == len(keys) and set(archive.files) == set(keys), 'Unexpected checkpoint array keys: ' + str(path))
return {name: archive[name].copy() for name in keys}
def validate_state(state, terminal, steps, *, fresh):
"""Validate local events/counts and the slots written by this segment."""
R.require(type(steps) is int and 0 < steps <= np.iinfo(np.int32).max, 'Invalid segment length')
for name in ('v', 'g'):
value = state[name]
R.require(value.dtype == np.float64 and value.shape == (N,) and np.isfinite(value).all(), 'Invalid parent ' + name)
for name in ('ref', 'counts'):
value = state[name]
R.require(value.dtype == np.int32 and value.shape == (N,) and np.all(value >= 0), 'Invalid parent ' + name)
R.require(np.all(state['ref'] <= 22), 'Parent refractory counter exceeds frozen 22-step contract')
tick, neuron = state['step'], state['neuron_idx']
R.require(tick.dtype == neuron.dtype == np.int32 and tick.ndim == neuron.ndim == 1 and tick.shape == neuron.shape,
'Invalid sparse event dtype/shape')
R.require(np.all((tick >= 0) & (tick < steps)) and np.all((neuron >= 0) & (neuron < N)), 'Parent event outside segment')
key = tick.astype(np.int64) * N + neuron
R.require(len(key) < 2 or np.all(key[1:] > key[:-1]), 'Parent events must be sorted and unique')
R.require(np.array_equal(np.bincount(neuron, minlength=N), state['counts']), 'Parent counts are not segment-local event counts')
ring = terminal['spike_ring']
R.require(ring.dtype == np.uint8 and ring.shape == (19, N) and np.all(ring <= 1), 'Invalid parent spike ring')
for name, shape in (('apl_state', (2,)), ('apl_pending', (18, 4064))):
value = terminal[name]
R.require(value.dtype == np.float32 and value.shape == shape and np.isfinite(value).all(), 'Invalid terminal ' + name)
phase = terminal['next_tick']
R.require(phase.dtype == np.int64 and phase.shape == () and phase.item() == steps, 'Terminal local phase does not match segment length')
for local_tick in range(max(0, steps - 19), steps):
start, stop = np.searchsorted(tick, (local_tick, local_tick + 1))
expected = np.zeros(N, dtype=np.uint8)
expected[neuron[start:stop]] = 1
R.require(np.array_equal(ring[local_tick % 19], expected), 'Spike ring does not match emitted segment events')
if fresh and steps < 19:
R.require(not np.any(ring[steps:]), 'Fresh parent has nonzero uninitialized spike slots')
return state, terminal
def _verify_receipt_hashes(directory, receipt):
for key, name in (('summary_sha256', 'summary.json'), ('finite_audit_sha256', 'finite-audit.json'),
('terminal_queues_sha256', 'terminal-queues.npz'), ('overlay_audit_sha256', 'overlay-audit.json')):
R.require(receipt.get(key) == R.digest(directory / name), 'Parent receipt hash mismatch: ' + name)
inputs = receipt.get('input_sha256')
R.require(isinstance(inputs, dict) and inputs, 'Parent receipt lacks immutable input bindings')
for name, sha in inputs.items():
R.require(Path(name).is_absolute() and R._sha(sha) and R.digest(name) == sha, 'Parent input/source bytes changed: ' + name)
def _validate_record(directory, seen):
summary = R._read_json(directory / 'summary.json')
finite = R._read_json(directory / 'finite-audit.json')
provenance = R._read_json(directory / 'runtime-provenance.json')
steps = summary.get('steps')
R.require(summary.get('complete') is True and summary.get('pass_all') is True and summary.get('all_finite') is True and
summary.get('completed_ticks') == steps and summary.get('nodes') == N and summary.get('edges') == E and
summary.get('precision') == 'float64' and summary.get('apl_precision') == 'float32' and
summary.get('within_trial_weight_updates') is False, 'Parent is not a complete fixed-weight fullgraph trial')
R.require(finite.get('all_finite') is True and finite.get('first_failure_tick') == -1 and
finite.get('finite_observed_ticks') == steps, 'Parent finite coverage failed')
R.require(provenance.get('complete') is True and provenance.get('weights_updated_during_run') is False and
provenance.get('old_globals_patched') is False, 'Invalid parent runtime receipt')
_verify_receipt_hashes(directory, provenance)
fresh = provenance.get('schema') == 'phase4an-reporting-adapter-v1'
if fresh:
R.require(provenance.get('source_sha256') == LIGHT_SHA and R.digest(provenance['source_file']) == LIGHT_SHA and
summary.get('checkpoint_continuation_used') is False, 'Fresh parent source/continuation scope mismatch')
offset = 0
else:
R.require(provenance.get('schema') == 'phase4an-continuation-runtime-v1' and
provenance.get('source_sha256') == R.digest(__file__) and
R.digest(provenance['source_file']) == R.digest(__file__) and
summary.get('checkpoint_continuation_used') is True, 'Unrecognized continued parent source')
receipt = R._read_json(directory / RECEIPT)
R.require(receipt.get('schema') == 'phase4an-continuation-receipt-v1' and receipt.get('complete') is True,
'Invalid continuation receipt')
R.require(receipt.get('weights_updated_during_run') is False and receipt.get('segment_steps') == steps and
receipt.get('counts_scope') == 'segment_only_not_lifetime' and
provenance.get('state_sha256') == R.digest(directory / 'state.npz'), 'Continued state/scope receipt mismatch')
expected_payload = _tree_hashes(directory)
expected_payload.pop(RECEIPT, None)
R.require(receipt.get('payload_sha256') == expected_payload, 'Continuation receipt does not bind the exact payload')
parent_pin = receipt.get('parent_checkpoint_manifest_sha256')
case_spec = _parent_spec({'summary': summary, 'provenance': provenance})
R.require(R._sha(parent_pin) and provenance.get('parent_checkpoint_manifest_sha256') == parent_pin and
summary.get('parent_checkpoint_manifest_sha256') == parent_pin and
case_spec.get('parent_checkpoint_manifest_sha256') == parent_pin,
'Parent checkpoint pin disagrees across case/summary/provenance/continuation receipts')
R.require(Path(receipt['parent_checkpoint_dir']).is_absolute(), 'Parent checkpoint directory is not absolute')
parent = load_checkpoint(receipt['parent_checkpoint_dir'], parent_pin, _seen=seen)
offset = parent['global_next_tick']
R.require(receipt.get('global_tick_offset') == offset and receipt.get('global_next_tick') == offset + steps and
summary.get('global_tick_offset') == offset and summary.get('global_next_tick') == offset + steps and
provenance.get('global_tick_offset') == offset and provenance.get('global_next_tick') == offset + steps,
'Continuation global clock chain mismatch')
R.require(summary.get('effective_weights_raw_sha256') == parent['summary'].get('effective_weights_raw_sha256'),
'Retention effective weights changed between parent and child')
state = _npz(directory / 'state.npz', ('step', 'neuron_idx', 'counts', 'v', 'g', 'ref'))
terminal = _npz(directory / 'terminal-queues.npz', ('spike_ring', 'apl_state', 'apl_pending', 'next_tick'))
validate_state(state, terminal, steps, fresh=fresh)
initial_padding = max(18 - (offset + steps), 0)
R.require(np.all(terminal['apl_pending'][:initial_padding].view(np.uint32) == 0),
'Unconsumed original APL padding is not positive zero')
if not fresh:
if steps < 19:
restored = rotate_spike_ring(parent['terminal']['spike_ring'], int(parent['terminal']['next_tick']))
R.require(np.array_equal(terminal['spike_ring'][steps:], restored[steps:]), 'Unwritten carried spike slots changed')
if steps < 18:
carried = parent['terminal']['apl_pending'][steps:]
R.require(np.array_equal(terminal['apl_pending'][:18 - steps].view(np.uint32), carried.view(np.uint32)),
'Unconsumed carried APL slots changed')
overlay = R._read_json(directory / 'overlay-audit.json')
R.require(overlay.get('complete') is True and overlay.get('weights_updated_during_run') is False and
overlay.get('effective_weights_raw_sha256') == summary.get('effective_weights_raw_sha256') and
overlay.get('mask_sha256') == R.MASK_SHA and overlay.get('am_helper_sha256') == R.AM_OVERLAY_SHA,
'Parent effective overlay receipt mismatch')
overlay_manifest = R._read_json(directory / 'overlay-manifest.json')
R.require(R.digest(directory / 'overlay-input.npz') == overlay_manifest.get('overlay_sha256') and
R.digest(directory / 'overlay-manifest.json') in provenance['input_sha256'].values() and
overlay_manifest.get('mask_sha256') == R.MASK_SHA and
overlay_manifest.get('base_candidate_sha256') == overlay.get('base_candidate_sha256'),
'Parent copied overlay inputs do not match their original receipt')
timing = R._read_json(directory / 'apl-timing-audit.json')
with (directory / 'apl-pending-tail.float32.npy').open('rb') as stream:
pending = np.load(stream, allow_pickle=False)
R.require(pending.dtype == np.float32 and pending.shape == (18, 4064) and
pending.tobytes() == terminal['apl_pending'].tobytes(), 'Parent terminal/pending output mismatch')
R.require(timing.get('pending_raw_sha256') == R._raw(pending) and timing.get('apl_delay_steps') == 18 and
timing.get('brain_tail_advanced') is False and
timing.get('final_apl_state_u32_bits') == terminal['apl_state'].view(np.uint32).tolist(), 'Parent APL terminal audit mismatch')
return {'directory': directory, 'summary': summary, 'provenance': provenance, 'overlay': overlay,
'state': state, 'terminal': terminal, 'steps': steps, 'global_tick_offset': offset,
'global_next_tick': offset + steps, 'fresh': fresh,
'ancestry_directories': [directory] if fresh else [directory, *parent['ancestry_directories']]}
def seal_checkpoint(checkpoint_dir):
"""Exclusive file-hash seal, not a brain run or proof of pre-seal integrity.
The returned manifest SHA must be externally pinned into the next case spec.
No existing receipt is overwritten. Fresh state.npz is newly bound here.
"""
directory = Path(checkpoint_dir).resolve(strict=True)
R.require(not (directory / MANIFEST).exists(), 'Checkpoint is already sealed')
before = _tree_hashes(directory)
record = _validate_record(directory, {directory})
R.require(before == _tree_hashes(directory), 'Checkpoint changed while sealing')
value = {'schema': 'phase4an-checkpoint-v1', 'complete': True, 'files_sha256': before,
'segment_steps': record['steps'], 'global_tick_offset': record['global_tick_offset'],
'global_next_tick': record['global_next_tick'], 'counts_scope': 'segment_only',
'state_binding_origin': 'checkpoint seal; fresh runtime receipt did not hash state.npz',
'pre_seal_state_integrity_independently_proven': False}
R._save(directory / MANIFEST, value)
return {'path': str(directory / MANIFEST), 'sha256': R.digest(directory / MANIFEST), **value}
def load_checkpoint(checkpoint_dir, expected_sha, *, _seen=None):
directory = Path(checkpoint_dir).resolve(strict=True)
R.require(R._sha(expected_sha) and R.digest(directory / MANIFEST) == expected_sha, 'Parent checkpoint manifest differs from external pin')
seen = set() if _seen is None else set(_seen)
R.require(directory not in seen, 'Checkpoint ancestry cycle')
seen.add(directory)
manifest = R._read_json(directory / MANIFEST)
R.require(manifest.get('schema') == 'phase4an-checkpoint-v1' and manifest.get('complete') is True and
manifest.get('counts_scope') == 'segment_only' and manifest.get('files_sha256') == _tree_hashes(directory),
'Checkpoint file inventory/hash mismatch')
record = _validate_record(directory, seen)
R.require(manifest.get('segment_steps') == record['steps'] and manifest.get('global_tick_offset') == record['global_tick_offset'] and
manifest.get('global_next_tick') == record['global_next_tick'], 'Checkpoint clock metadata mismatch')
R.require(manifest['files_sha256'] == _tree_hashes(directory) and R.digest(directory / MANIFEST) == expected_sha,
'Checkpoint changed while loading')
record.update(manifest=manifest, manifest_sha256=expected_sha)
return record
def derive_continued(source_bytes, mode):
"""One explicit arrival-admission edit plus one pre-loop restore hook."""
tree, inherited = R.derive_ast(source_bytes, mode)
original = copy.deepcopy(tree)
function = tree.body[-1]
body = next(node for node in function.body if isinstance(node, ast.Try)).body
candidates = [i for i, node in enumerate(body) if isinstance(node, ast.Assign) and
len(node.targets) == 1 and isinstance(node.targets[0], ast.Name) and node.targets[0].id == 'apl_ring']
R.require(len(candidates) == 1, 'Expected one APL ring initialization')
body.insert(candidates[0] + 1, ast.parse(RESTORE).body[0])
clocks = [node for node in ast.walk(function) if isinstance(node, ast.If) and ast.unparse(node.test) == CLOCK_OLD]
R.require(len(clocks) == 1, 'Expected exact original local arrival-admission condition')
clocks[0].test = ast.parse(CLOCK_NEW, mode='eval').body
tree = ast.fix_missing_locations(tree)
# Independently reverse exactly the two edits, then require the ENTIRE AST.
rollback = copy.deepcopy(tree)
reverse_body = next(node for node in rollback.body[-1].body if isinstance(node, ast.Try)).body
restores = [i for i, node in enumerate(reverse_body) if ast.unparse(node) == RESTORE]
reverse_clocks = [node for node in ast.walk(rollback) if isinstance(node, ast.If) and ast.unparse(node.test) == CLOCK_NEW]
R.require(len(restores) == len(reverse_clocks) == 1, 'Ambiguous continuation edit rollback')
del reverse_body[restores[0]]
reverse_clocks[0].test = ast.parse(CLOCK_OLD, mode='eval').body
R.require(R._dump(rollback) == R._dump(original), 'Additional unlisted continuation AST edit')
audit = {'base': inherited, 'restore_hook': RESTORE, 'clock_admission_old': CLOCK_OLD,
'clock_admission_new': CLOCK_NEW, 'full_AST_rollback_identical': True,
'kernels_sorting_and_local_ring_math_unchanged': True,
'derived_module_ast_sha256': hashlib.sha256(R._dump(tree).encode()).hexdigest()}
return tree, audit
def audit_carried_sequence(generated, applied, pending, initial_pending):
"""Bitwise FIFO accounting with a carried queue, never a new brain step."""
for name, value in (('generated', generated), ('applied', applied), ('pending', pending), ('initial', initial_pending)):
R.require(isinstance(value, np.ndarray) and value.dtype == np.float32 and value.ndim == 2 and
np.isfinite(value).all() and np.all(value >= 0), 'Invalid continued APL trace: ' + name)
R.require(generated.shape == applied.shape and pending.shape == initial_pending.shape == (18, generated.shape[1]),
'Continued APL sequence shapes differ')
steps = len(generated)
for tick in range(steps + 18):
actual = applied[tick] if tick < steps else pending[tick - steps]
expected = initial_pending[tick] if tick < 18 else generated[tick - 18]
R.require(np.array_equal(actual.view(np.uint32), expected.view(np.uint32)),
'Carried FIFO bitwise accounting failed at local application tick ' + str(tick))
return {'pass_all': True, 'apl_delay_steps': 18, 'steps': steps, 'sample_bits_preserved': True,
'initial_queue_from_parent': True, 'initial_queue_raw_sha256': R._raw(initial_pending),
'full_sequence_bitwise_audit_performed': True, 'brain_tail_advanced': False}
class ContinuedRuntime(R._Runtime):
def __init__(self, *args, parent, **kwargs):
super().__init__(*args, **kwargs)
self.parent = parent
self.global_offset = parent['global_next_tick']
self.restorations = 0
def install(self, *args, **kwargs):
super().install(*args, **kwargs)
R.require(self.effective_sha == self.parent['summary']['effective_weights_raw_sha256'], 'Retention changed effective weights')
def restore(self, v, g, ref, counts, ring, apl_ring, apl, upload):
R.require(self.installations == 1 and self.restorations == 0, 'Restore must occur once after fixed-weight installation')
R.require(not bool(counts.any().item()), 'Segment counts must start at zero')
state, terminal = self.parent['state'], self.parent['terminal']
for target, value, dtype in ((v, state['v'], self.torch.float64), (g, state['g'], self.torch.float64),
(ref, state['ref'], self.torch.int32),
(ring, rotate_spike_ring(terminal['spike_ring'], int(terminal['next_tick'])), self.torch.uint8),
(apl_ring, terminal['apl_pending'], self.torch.float32),
(apl.state, terminal['apl_state'], self.torch.float32)):
target.copy_(upload(value, dtype))
self.restorations += 1
def finish(self, *args, **kwargs):
R.require(self.restorations == 1, 'Continuation was not restored')
return super().finish(*args, **kwargs)
def audit_sequence(self, generated, applied, pending, delay):
R.require(delay == 18, 'Continuation changed D18')
return audit_carried_sequence(generated, applied, pending, self.parent['terminal']['apl_pending'])
def _timing_metadata(self, value):
result = dict(value)
next_tick, steps = self.global_offset + self.spec['steps'], self.spec['steps']
result.pop('initial_padding_positive_zero', None)
result.update(initial_queue_from_parent=True, initial_queue_raw_sha256=R._raw(self.parent['terminal']['apl_pending']),
global_tick_offset=self.global_offset, global_next_tick=next_tick, tick_coordinate='global',
segment_steps=steps, segment_generated_rows_applied=max(steps - 18, 0),
applied_parent_pending_rows=min(steps, 18),
applied_initial_zero_rows=min(steps, max(18 - self.global_offset, 0)),
applied_parent_generated_rows=min(steps, 18) - min(steps, max(18 - self.global_offset, 0)),
pending_segment_generated_rows=min(steps, 18),
pending_parent_generated_rows=max(18 - steps, 0) - max(18 - next_tick, 0),
pending_generated_count=min(next_tick, 18), pending_initial_zero_prefix=max(18 - next_tick, 0),
pending_application_tick_start=next_tick, pending_application_tick_stop_exclusive=next_tick + 18,
pending_generated_tick_start=max(0, next_tick - 18), pending_generated_tick_stop_exclusive=next_tick,
brain_tail_advanced_scope='no extra brain ticks beyond this explicit segment')
if self.mode == 'light':
result.update(generated_trace=None, applied_trace=None, full_sequence_bitwise_audit_performed=False,
scope='Original D18 ring math retained with restored queue; histories not recorded')
return result
def timing(self, steps, pending):
return self._timing_metadata(super().timing(steps, pending))
def summary(self, value):
result = super().summary(value)
result.update(checkpoint_continuation_used=True, global_tick_offset=self.global_offset,
global_next_tick=self.global_offset + self.spec['steps'], event_tick_scope='segment_local',
counts_scope='segment_only_not_lifetime', parent_checkpoint_manifest_sha256=self.parent['manifest_sha256'])
result.update(pending_generated_count=min(result['global_next_tick'], 18),
pending_initial_zero_prefix=max(18 - result['global_next_tick'], 0))
if 'apl_timing' in result:
result['apl_timing'] = self._timing_metadata(result['apl_timing'])
return result
def write_json(self, path, value):
if Path(path).name == 'apl-timing-audit.json':
value = self._timing_metadata(value)
return super().write_json(path, value)
def compile_continued(aj, runtime, mode):
tree, audit = derive_continued(Path(aj.__file__).read_bytes(), mode)
namespace = dict(aj.__dict__)
namespace.update(__name__=__name__ + '.derived_' + mode, __file__=str(Path(__file__).resolve()),
_runtime=runtime, _continuation=runtime, write_json=runtime.write_json,
audit_sequence=runtime.audit_sequence)
audit['diagnostic_namespace_binding'] = 'audit_sequence checks parent_pending + generated, not an assumed zero-initial queue'
exec(compile(tree, str(Path(__file__).resolve()) + '::continued-AJ-AST-' + mode, 'exec'), namespace)
return namespace['run_gpu'], audit
def _parent_spec(parent):
expected = parent['summary']['input_sha256']['spec.json']
paths = [Path(path) for path, sha in parent['provenance']['input_sha256'].items()
if Path(path).name == 'spec.json' and sha == expected]
R.require(len(paths) == 1, 'Ambiguous original parent case spec')
return R._read_json(paths[0])
def run_continued(case_dir, out_dir, build_root, overlay_file, overlay_manifest, checkpoint_dir, *, mode='light'):
R.require(sys.dont_write_bytecode, 'Use python -B; frozen sources must not receive bytecode writes')
R.require(mode in ('light', 'reference'), 'Invalid diagnostic mode')
case_dir, out_dir, build_root = R.execution_paths(case_dir, out_dir, build_root, (checkpoint_dir,))
spec = R._read_json(case_dir / 'spec.json')
parent_sha = spec.get('parent_checkpoint_manifest_sha256')
fresh_admission = dict(spec)
fresh_admission.pop('parent_checkpoint_manifest_sha256', None)
R.validate_spec(fresh_admission, case_dir)
parent = load_checkpoint(checkpoint_dir, parent_sha)
# A continuation may never create output or a build cache inside ANY
# immutable ancestor, not only its immediate checkpoint parent. This check
# precedes overlay imports, Torch imports, compilation and output creation.
case_dir, out_dir, build_root = R.execution_paths(case_dir, out_dir, build_root, parent['ancestry_directories'])
if 'global_tick_offset' in spec:
R.require(type(spec['global_tick_offset']) is int and spec['global_tick_offset'] == parent['global_next_tick'],
'Declared global offset disagrees with checkpoint chain')
R.require(parent['global_next_tick'] + spec['steps'] <= np.iinfo(np.int64).max, 'Absolute tick overflow')
helper, plan, meta, inputs = R.load_overlay(overlay_file, overlay_manifest)
R.require(R.digest(overlay_file) == R.digest(parent['directory'] / 'overlay-input.npz') and
R.digest(overlay_manifest) == R.digest(parent['directory'] / 'overlay-manifest.json'), 'Retention overlay snapshot/manifest changed')
previous = _parent_spec(parent)
for key in ('dt_ms', 'model', 'apl', 'apl_delay_steps'):
R.require(spec[key] == previous[key], 'Continuation changes frozen dynamics: ' + key)
for key in ('graph_dir', 'apl_bundle_dir'):
R.require(Path(spec[key]).resolve(strict=True) == Path(previous[key]).resolve(strict=True), 'Continuation changes input directory: ' + key)
R.require(R.digest(spec['coefficients_path']) == parent['summary']['input_sha256']['coefficients.json'], 'Continuation coefficients changed')
R.require(R.digest(Path(spec['graph_dir']) / 'weights.npy') == parent['summary']['input_sha256']['base_weights.npy'], 'Continuation base weights changed')
aj_dir = Path(meta['aj_model_dir']).resolve(strict=True)
protected = (aj_dir.parent, Path(meta['am_overlay_path']).resolve().parent, spec['graph_dir'], spec['apl_bundle_dir'],
*parent['ancestry_directories'],
*(Path(path).resolve(strict=True).parent for path in
(overlay_file, overlay_manifest, meta['mask_path'], meta['base_candidate_path'], spec['coefficients_path'])))
case_dir, out_dir, build_root = R.execution_paths(case_dir, out_dir, build_root, protected)
for path in (case_dir / 'spec.json', case_dir / 'requests.npz', Path(spec['graph_dir']) / 'weights.npy',
Path(spec['coefficients_path']), Path(checkpoint_dir).resolve() / MANIFEST, Path(R.__file__).resolve()):
inputs[str(path)] = R.digest(path)
source_sha = R.digest(__file__)
R._load('timing_queue', aj_dir / 'timing_queue.py', R.PINS['apl-timing-lab-v1/timing_queue.py'])
aj = R._load('phase4an_continued_sealed_aj_gpu', aj_dir / 'gpu_timing.py', R.AJ_SHA)
runtime = ContinuedRuntime(mode, spec, helper, plan, meta, inputs, aj.torch, overlay_file, overlay_manifest, parent=parent)
function, ast_audit = compile_continued(aj, runtime, mode)
try:
inherited = function(case_dir, out_dir, build_root)
R.require(runtime.finished and runtime.restorations == 1 and runtime.installations == 1 and inherited['complete'], 'Incomplete continuation')
R.require(inherited['effective_weights_raw_sha256'] == runtime.effective_sha, 'Effective weight identity changed')
R.require(source_sha == R.digest(__file__) and all(R.digest(path) == sha for path, sha in inputs.items()), 'Source/input changed during continuation')
load_checkpoint(checkpoint_dir, parent_sha)
summary = R._read_json(out_dir / 'summary.json')
R.require(summary == runtime.summary(inherited), 'Stored continuation summary mismatch')
provenance = {'schema': 'phase4an-continuation-runtime-v1', 'complete': True, 'mode': mode,
'source_file': str(Path(__file__).resolve()), 'source_sha256': source_sha, 'fresh_runtime_sha256': LIGHT_SHA,
'ast': ast_audit, 'input_sha256': inputs, 'old_globals_patched': False, 'weights_updated_during_run': False,
'learning_pass_claimed': False, 'global_tick_offset': runtime.global_offset,
'global_next_tick': runtime.global_offset + spec['steps'],
'parent_checkpoint_manifest_sha256': parent_sha}
for key, name in (('summary_sha256', 'summary.json'), ('finite_audit_sha256', 'finite-audit.json'),
('terminal_queues_sha256', 'terminal-queues.npz'), ('overlay_audit_sha256', 'overlay-audit.json'),
('state_sha256', 'state.npz')):
provenance[key] = R.digest(out_dir / name)
R._save(out_dir / 'runtime-provenance.json', provenance)
receipt = {'schema': 'phase4an-continuation-receipt-v1', 'complete': True,
'parent_checkpoint_dir': str(parent['directory']), 'parent_checkpoint_manifest_sha256': parent_sha,
'global_tick_offset': runtime.global_offset, 'global_next_tick': runtime.global_offset + spec['steps'],
'segment_steps': spec['steps'], 'counts_scope': 'segment_only_not_lifetime',
'payload_sha256': _tree_hashes(out_dir), 'weights_updated_during_run': False,
'clock_admission_edit': CLOCK_NEW, 'checkpoint_continuation_verified_by_GPU_comparison': False}
R._save(out_dir / RECEIPT, receipt)
sealed = seal_checkpoint(out_dir)
return dict(summary, checkpoint_manifest_sha256=sealed['sha256'])
except Exception as error:
if out_dir.is_dir() and not (out_dir / 'continuation-error.json').exists():
R._save(out_dir / 'continuation-error.json', {'complete': False, 'type': type(error).__name__,
'message': str(error), 'learning_update_forbidden': True})
raise