From bc0c5e253056ed28ee96b00097b9d3138ada6164 Mon Sep 17 00:00:00 2001 From: igneum-labs <337424239+igneum-labs@users.noreply.github.com> Date: Thu, 8 Oct 2026 20:44:19 +0000 Subject: [PATCH 1/4] same-work: the P01 driver prepares the day D+1 pair before the first job across the boundary (prepare, prepared, prepare-failed and a prepare-0 worker in the self-test); the spec page carried for the readers until ci-f03-manifest lands Co-Authored-By: Claude Fable 5.1 --- docs/plans/igneum-2.0-same-work-test.md | 48 ++++++++++ tools/ci/p01-vectors.py | 119 +++++++++++++++++++++--- 2 files changed, 156 insertions(+), 11 deletions(-) create mode 100644 docs/plans/igneum-2.0-same-work-test.md diff --git a/docs/plans/igneum-2.0-same-work-test.md b/docs/plans/igneum-2.0-same-work-test.md new file mode 100644 index 000000000..6ecfdd5c8 --- /dev/null +++ b/docs/plans/igneum-2.0-same-work-test.md @@ -0,0 +1,48 @@ +# The cross-backend same-work test (F03, Review B; specified by the CI steward, 8 October 2026, 20:1x UK) + +One job context, six readers, three phases around a transition, bit-for-bit agreement. Run by the fleet lane with the freeze object; the evidence recorded against POW-01 through the batch tools. + +## The job context (one file, `job-context.json`, written once by the steward or the hash lane and copied to every reader) + +| Field | Value tonight | Source | +|---|---|---| +| object | the class v5 freeze: igneum-pow 1c420786, fingerprint cbc5bd0aa10585c8576e71e37a8ee47a045ae51754e9ddf749d0c21e6a535f88 | packaging/release-manifest.json (generator) | +| epoch seed bytes | edc4fa844da9dc98d37e965176f6558a31560e40502ab3ae5491b21aaaabfb07 (the genesis seeds) | the hash lane's P01 line | +| day bytes | 69676e65756d2d6461792ffa50000000000000 | the hash lane's P01 line | +| class | 5; era 0: | the pack's program.json | +| prehash | 0000000000000000000000000000000000000000000000000000000000000001 | the P01 convention | +| nonce range | 0 .. 2^20 per phase (three phases, three ranges: [0, 2^20), [2^20, 2^21), [2^21, 2^22)) | this page | +| transition | the day boundary: day D for phase 1, the boundary block for phase 2 (the last 2^12 nonces of day D and the first 2^12 of day D+1 as the engine sees them under fast-time 60x), day D+1 for phase 3 | infra/fast-time/override-60x.json | + +The transition is a dataset-day rotation (the class and era unchanged, the day bytes change), the one transition every live network crosses hourly at 60x; a class rotation (v5 to v6) is the same test with `class` and the second `day bytes` changed and runs only on a research object until a v6 floor is set. + +## The six readers (every one writes `-.json` of the P01 driver's evidence shape: nonce, hash per line in the raw file; agree, disagree, missing, the first ten disagreements, the device line, the pack and program ids, the manifest sha in the JSON) + +1. **node**: `igneumd` at the manifest's node sha, the engine's own re-check (`IgneumEngine::epoch_for` then `hash_bound` per nonce) through `igneum-miner --recheck-vectors` on the node binary's CPU path (the pool.rs seam), on build-2. +2. **CPU reference**: `igneum-pow hash-bound --count 2^20 --nonce ` from the manifest's generator commit, on build-2 (the hash lane's reference files are this reader). +3. **CUDA**: the kit's `igneum-worker-cuda --serve` driven by `tools/ci/p01-vectors.py` with the job context, on a 5090, 4090 and 3090 pod. +4. **OpenCL**: `igneum-worker-opencl --serve` the same way, on the AMD pod when one exists, else PC 1's RX 7600 (the only OpenCL retail cell tonight). +5. **Metal**: the Mac's own worker, the same driver, on the mini (the morning's run; never on this Mac). +6. **pool**: `igneum-pool` at the manifest's sha with its vendored node at the manifest's node sha, the member-side re-check (`pool/src/node.rs` → `kaspa_pow::igneum::IgneumEngine`) on the same job lines, on build-2. + +## The three phases + +Phase 1 (before): every reader on range 1 under day D. Phase 2 (during): every reader on range 2 where the engine's day moves from D to D+1 inside the range at the boundary nonce the fast-time clock sets; every reader must switch program and dataset at the same nonce. Phase 3 (after): every reader on range 3 under day D+1. + +## Acceptance (the registry row POW-01, cell `harness:same-work`, PASS only when all hold) + +- every reader's hash equals the CPU reference's for every nonce of every phase (zero disagreements, zero missing); +- the program id and the day each reader reports at phase 2's boundary are the same across readers (the transition is seen at one nonce); +- the pool's accepted-share verdict for a sample of 64 nonces per phase equals the node's (the seam closes by a build: `release-manifest-check.sh` refuses a redefined EpochSeeds and an unpinned vendored node); +- the run names the manifest sha (packaging/release-manifest.json), and the evidence sits at build-1:/srv/artefacts/tas/same-work-/. + +A disagreement on any reader is a red to main within fifteen minutes (the coordinator's rule for the cross-checks). + +## What is still to build (owners, defaults) + +| Piece | Owner | Clock | Default if silent | +|---|---|---|---| +| `p01-vectors.py --job-context --phase N` (the three ranges and the boundary assertion; the driver already drives the workers) | CI steward | 21:30 | built as specified | +| the node reader (`igneum-miner --recheck-vectors`, the seam with a count) | node lane | 22:00 | the steward builds it on a branch of release-2.0.0-node under rule 24 | +| the pool reader (the member-side re-check over a job-lines file) | pool lane | 22:30 | the pool's existing recheck_pack path over the context, driven by the steward | +| the pods and the mini | fleet lane | on the artefact line | as P01 | diff --git a/tools/ci/p01-vectors.py b/tools/ci/p01-vectors.py index 8ed7f724d..626abc67c 100755 --- a/tools/ci/p01-vectors.py +++ b/tools/ci/p01-vectors.py @@ -11,7 +11,16 @@ the worker never answered. tools/ci/p01-vectors.py --worker [--worker-arg=X ...] --pack --reference --count 1000000 (a worker argument that itself starts with "--" must be given as --worker-arg=--serve; argparse reads "--worker-arg --serve" as two options) [--start 0] [--job-nonces 1048576] [--prehash <64 hex>] [--manifest ] --out + tools/ci/p01-vectors.py --worker [--worker-arg X ...] --job-context --phase 1|2|3 --out tools/ci/p01-vectors.py --self-test +The job context (the same-work test, docs/plans/igneum-2.0-same-work-test.md) names two packs and two references (day D and +day D+1), the prehash, the range width (range_log2, 20) and the boundary nonce; phase N runs nonces [(N-1)*2^w, N*2^w): phase 1 +under day D, phase 3 under day D+1, phase 2 under day D up to the boundary nonce and day D+1 from it, no job line crossing the +boundary, and the evidence carries the boundary block (the nonce, the program id and day bytes on each side, the two hashes +either side) that the readers are compared on. A worker holds one (epoch, day) pair, so before any job the driver sends the +worker `prepare ` and waits for its `prepared` line (a `prepare-failed` line or +a ready line saying `prepare 0` is an error: the day switch cannot be driven); the first job on day D+1 then switches the pair, +as the miner does at a real day switch. The job line is pool.rs's: `job class= era=`. """ import argparse, json, os, subprocess, sys, tempfile, time @@ -31,21 +40,62 @@ def pack_fields(pack): cls = j.get('program_class', '?'); era = j.get('era_seed_bytes', '') return j.get('seed_bytes', ''), j['dataset']['day_bytes'], cls, era, j.get('program_id', '?'), j.get('generator', '?') +def segments_for(a): + """[(start, end, pack dir, reference path)] with no job crossing a segment edge; one segment for the plain form.""" + if not a.job_context: return [(a.start, a.start + a.count, a.pack, a.reference)], None + jc = json.load(open(a.job_context)); w = int(jc.get('range_log2', 20)); n = int(a.phase) + if n not in (1, 2, 3): raise SystemExit('p01-vectors: --phase must be 1, 2 or 3') + base = os.path.dirname(os.path.abspath(a.job_context)) + pth = lambda x: x if os.path.isabs(x) else os.path.join(base, x) + packs, refs = jc['packs'], jc['references'] + s0, e0 = (n - 1) << w, n << w + if n == 1: segs = [(s0, e0, pth(packs['D']), pth(refs['D']))] + elif n == 3: segs = [(s0, e0, pth(packs['D1']), pth(refs['D1']))] + else: + b = int(jc['boundary_nonce']) + if not (s0 < b < e0): raise SystemExit(f'p01-vectors: the boundary nonce {b} is not inside phase 2 [{s0}, {e0})') + segs = [(s0, b, pth(packs['D']), pth(refs['D'])), (b, e0, pth(packs['D1']), pth(refs['D1']))] + a.start, a.count = s0, e0 - s0 + if jc.get('prehash'): a.prehash = jc['prehash'] + if jc.get('manifest') and not a.manifest: a.manifest = jc['manifest'] + return segs, jc + def run(a): - ref = read_reference(a.reference) - seed_bytes, day_bytes, cls, era, program_id, generator = pack_fields(a.pack) + segs, jc = segments_for(a) + ref = {}; seg_fields = [] + for (ss, se, pack, rpath) in segs: + r = read_reference(rpath); ref.update({k: v for k, v in r.items() if ss <= k < se}); seg_fields.append((ss, se, pack_fields(pack))) + seed_bytes, day_bytes, cls, era, program_id, generator = seg_fields[0][2] + def fields_at(n): + for (ss, se, f) in seg_fields: + if ss <= n < se: return ss, se, f + return None p = subprocess.Popen([a.worker] + a.worker_arg, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1) ready = None; t0 = time.time() for line in p.stdout: if line.startswith('ready'): ready = line.strip(); break if time.time() - t0 > 120: break if not ready: p.kill(); return {'error': 'the worker never said ready'}, 2 + prepared = None + if len(seg_fields) > 1: + # the second segment's pair (day D+1) is prepared before any job: the worker builds it in the background and the first + # job on that day switches to it; a worker without prepare support cannot be driven across the boundary + if ' prepare 0' in ready: p.kill(); return {'error': f'the worker has no prepare support (ready line: {ready}); phase 2 needs it for the day switch'}, 2 + ss2, se2, (sb2, db2, _c2, _er2, _pid2, _gen2) = seg_fields[1] + p.stdin.write(f"prepare {sb2} {db2} {segs[1][2]}\n"); p.stdin.flush() + t1 = time.time() + for line in p.stdout: + if line.startswith('prepared '): prepared = line.strip(); break + if line.startswith('prepare-failed'): p.kill(); return {'error': f'the worker refused the day D+1 pair: {line.strip()[:300]}'}, 2 + if time.time() - t1 > 900: break + if not prepared: p.kill(); return {'error': 'the worker never said prepared for the day D+1 pair (900 s)'}, 2 got = {}; agree = 0; disagree = []; seq = 0; start = a.start; end = a.start + a.count; pending = set() def feed(): nonlocal seq, start while start < end and len(pending) < 4: - n = min(a.job_nonces, end - start); seq += 1 - p.stdin.write(f"job {seq} {a.prehash} {'f'*16} {start} {n} {seed_bytes} {day_bytes} class={cls} era={era}\n"); p.stdin.flush() + ss, se, (sb, db, c, er, _pid, _gen) = fields_at(start) + n = min(a.job_nonces, end - start, se - start); seq += 1 # a job never crosses a segment edge (the day boundary) + p.stdin.write(f"job {seq} {a.prehash} {'f'*16} {start} {n} {sb} {db} class={c} era={er}\n"); p.stdin.flush() pending.add(seq); start += n feed() for line in p.stdout: @@ -68,11 +118,21 @@ def run(a): except Exception: pass p.wait(timeout=30) missing = [n for n in range(a.start, end) if n not in got] - ev = {'case': 'POW-01', 'profile': 'P01', 'pack': os.path.basename(os.path.abspath(a.pack)), 'program_id': program_id, 'generator': generator, 'class': cls, + pack_name = os.path.basename(os.path.abspath(a.pack)) if a.pack else ', '.join(os.path.basename(os.path.abspath(s[2])) for s in segs) + ev = {'case': 'POW-01', 'profile': 'P01', 'pack': pack_name, 'program_id': program_id, 'generator': generator, 'class': cls, 'worker': a.worker, 'worker_args': a.worker_arg, 'device_line': ready, 'manifest_sha': a.manifest, 'prehash': a.prehash, 'nonces': {'start': a.start, 'count': a.count}, 'answered': len(got), 'agree': agree, 'disagree': disagree_count[0], 'missing': len(missing), 'first_disagreements': disagree, 'first_missing': missing[:10], 'worker_errors': errors[:10], 'seconds': round(time.time() - t0, 1), 'at': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())} - ev['verdict'] = 'PASS' if (agree == a.count and not disagree and not missing) else 'FAIL' + if jc is not None: + ev['job_context'] = os.path.abspath(a.job_context); ev['phase'] = int(a.phase); ev['object'] = jc.get('object') + ev['segments'] = [{'start': ss, 'end': se, 'program_id': f[4], 'day_bytes': f[1], 'class': f[2], 'pack': os.path.basename(os.path.abspath(sg[2]))} for (ss, se, f), sg in zip(seg_fields, segs)] + if prepared: ev['prepare_line'] = prepared + if len(seg_fields) == 2: + b = seg_fields[1][0]; fb, fa = seg_fields[0][2], seg_fields[1][2] + ev['boundary'] = {'nonce': b, 'program_id_before': fb[4], 'program_id_after': fa[4], 'day_bytes_before': fb[1], 'day_bytes_after': fa[1], + 'hash_before': got.get(b - 1), 'hash_after': got.get(b), 'reference_before': ref.get(b - 1), 'reference_after': ref.get(b), + 'switched': bool(fb[1] != fa[1] and got.get(b - 1) == ref.get(b - 1) and got.get(b) == ref.get(b))} + ev['verdict'] = 'PASS' if (agree == a.count and not disagree and not missing and (jc is None or len(seg_fields) < 2 or ev['boundary']['switched'])) else 'FAIL' return ev, (0 if ev['verdict'] == 'PASS' else 1) disagree_count = [0]; errors = [] @@ -84,14 +144,20 @@ def self_test(): # a fake worker: hashes nonce n as (n * 0x9e3779b97f4a7c15) mod 2^64; nonce 7 wrong when WRONG=1; nonce 9 never answered when DROP=1 w = os.path.join(d, 'worker.py') open(w, 'w').write('''import sys, os -print("ready fake-gpu 0 prepare 1", flush=True) +print("ready fake-gpu 0 prepare " + ("0" if os.environ.get("NOPREPARE") == "1" else "1"), flush=True) +resident = {os.environ.get("RESIDENT", "cc" * 19)} # the pack's day (the real worker starts on its --pack); another day needs prepare first, as the real worker (day seed mismatch otherwise) for line in sys.stdin: p = line.split() + if p[0] == "prepare": + if os.environ.get("PREPFAIL") == "1": print(f"prepare-failed {p[1]} {p[2]} nvcc exit 1", flush=True); continue + resident.add(p[2]); print(f"prepared {p[1]} {p[2]} 12.0 nvcc 10.0 cache 1.0 dataset 1.0 resident 2 programs 2 datasets", flush=True); continue if p[0] != "job": continue seq, start, n = int(p[1]), int(p[4]), int(p[5]) + if p[7] not in resident: print(f"error {seq} day seed mismatch: the job's day seed {p[7]} is not resident", flush=True); print(f"done {seq} 0 0", flush=True); continue for k in range(start, start + n): if os.environ.get("DROP") == "1" and k == 9: continue h = (k * 0x9e3779b97f4a7c15) % (1 << 64) + if p[7] == "dd" * 19: h ^= 0xdd00dd00dd00dd00 # day D+1's bytes hash differently (a reader on the wrong day disagrees) if os.environ.get("WRONG") == "1" and k == 7: h ^= 1 print(f"found {seq} {k} {h:016x}", flush=True) print(f"done {seq} {n} 1.0", flush=True) @@ -107,15 +173,46 @@ for line in sys.stdin: if not (rc == 1 and ev.get('verdict') == 'FAIL' and ev['disagree'] == 1 and ev['first_disagreements'][0]['nonce'] == 7): print(f"self-test failed: one wrong hash was not a FAIL naming nonce 7: rc={rc} {ev.get('first_disagreements')}"); fails = 1 rc, ev = go({'DROP': '1'}, 'drop') if not (rc == 1 and ev['missing'] == 1 and ev['first_missing'] == [9]): print(f"self-test failed: an unanswered nonce was not a FAIL naming nonce 9: rc={rc} {ev.get('first_missing')}"); fails = 1 - if not fails: print('self-test passed: a clean million-shape run is PASS with the counts; one wrong hash is FAIL naming the nonce, the gpu and cpu hashes; an unanswered nonce is FAIL naming it; the job lines carry the pack fields and the all-pass target') + # the job-context form: two packs (day D cc.., day D+1 dd..), two references, range_log2 4 (16 nonces a phase), boundary 24 inside phase 2 + pack2 = os.path.join(d, 'pack2'); os.makedirs(pack2) + json.dump({'seed_bytes': 'aa' * 32, 'program_class': 'v5', 'era_seed_bytes': 'bb' * 32, 'program_id': '0x2', 'generator': 5, 'dataset': {'day_bytes': 'dd' * 19, 'log2_words': 20}}, open(os.path.join(pack2, 'program.json'), 'w')) + refD = os.path.join(d, 'refD.txt'); open(refD, 'w').write(''.join(f"{k} {(k * 0x9e3779b97f4a7c15) % (1 << 64):016x}\n" for k in range(0, 48))) + refD1 = os.path.join(d, 'refD1.txt'); open(refD1, 'w').write(''.join(f"{k} {((k * 0x9e3779b97f4a7c15) % (1 << 64)) ^ 0xdd00dd00dd00dd00:016x}\n" for k in range(0, 48))) + jc = os.path.join(d, 'job-context.json') + json.dump({'object': 'fake', 'prehash': '00' * 31 + '01', 'range_log2': 4, 'boundary_nonce': 24, 'manifest': 'deadbeef', 'packs': {'D': pack, 'D1': pack2}, 'references': {'D': refD, 'D1': refD1}}, open(jc, 'w')) + def gojc(phase, tag, boundary=None, env=None): + if boundary is not None: + j = json.load(open(jc)); j['boundary_nonce'] = boundary; json.dump(j, open(jc, 'w')) + out = os.path.join(d, f'{tag}.json'); e = dict(os.environ); e.update(env or {}) + r = subprocess.run([sys.executable, __file__, '--worker', sys.executable, '--worker-arg', w, '--job-context', jc, '--phase', str(phase), '--job-nonces', '8', '--out', out], capture_output=True, text=True, env=e) + return r.returncode, (json.load(open(out)) if os.path.exists(out) else {}), r.stdout + r.stderr + for ph, s0, pid in ((1, 0, '0x1'), (3, 32, '0x2')): + rc, ev, o = gojc(ph, f'jc{ph}', env={'RESIDENT': 'dd' * 19} if ph == 3 else None) # phase 3's worker starts on the day D+1 pack + if not (rc == 0 and ev.get('verdict') == 'PASS' and ev['nonces'] == {'start': s0, 'count': 16} and ev['segments'][0]['program_id'] == pid and 'boundary' not in ev): print(f"self-test failed: phase {ph} of the job context was not a PASS on its range and pack: rc={rc} {ev.get('nonces')} {ev.get('segments')} {o[-200:]}"); fails = 1 + rc, ev, o = gojc(2, 'jc2') + b = ev.get('boundary', {}) + if not (rc == 0 and ev.get('verdict') == 'PASS' and ev['nonces'] == {'start': 16, 'count': 16} and b.get('nonce') == 24 and b.get('program_id_before') == '0x1' and b.get('program_id_after') == '0x2' and b.get('switched') is True and len(ev['segments']) == 2): print(f"self-test failed: phase 2 did not switch pack at the boundary nonce 24 with the boundary block: rc={rc} {b} {o[-200:]}"); fails = 1 + if not (b.get('switched') is True and str(ev.get('prepare_line', '')).startswith('prepared ' + 'aa' * 32 + ' ' + 'dd' * 19) and ev['segments'][1]['pack'] == 'pack2'): print(f"self-test failed: phase 2 did not prepare the day D+1 pair before the first job on it: {ev.get('prepare_line')} {ev.get('segments')}"); fails = 1 + rc, ev, o = gojc(2, 'jc2noprep', env={'NOPREPARE': '1'}) + if rc != 2 or 'no prepare support' not in o: print(f"self-test failed: a worker without prepare support was not refused for phase 2: rc={rc} {o[-200:]}"); fails = 1 + rc, ev, o = gojc(2, 'jc2prepfail', env={'PREPFAIL': '1'}) + if rc != 2 or 'refused the day D+1 pair' not in o: print(f"self-test failed: a prepare-failed line was not an error: rc={rc} {o[-200:]}"); fails = 1 + rc, ev, o = gojc(2, 'jc2bad', boundary=40) + if rc == 0 or 'not inside phase 2' not in o: print(f"self-test failed: a boundary outside phase 2 was not refused: rc={rc} {o[-200:]}"); fails = 1 + if not fails: print('self-test passed: a clean million-shape run is PASS with the counts; one wrong hash is FAIL naming the nonce, the gpu and cpu hashes; an unanswered nonce is FAIL naming it; the job-context form runs each phase on its range and pack, splits phase 2 at the boundary nonce with the boundary block, and refuses a boundary outside phase 2; the job lines carry the pack fields and the all-pass target') return fails if __name__ == '__main__': if '--self-test' in sys.argv: sys.exit(self_test()) - ap = argparse.ArgumentParser(); ap.add_argument('--worker', required=True); ap.add_argument('--worker-arg', action='append', default=[]); ap.add_argument('--pack', required=True) - ap.add_argument('--reference', required=True); ap.add_argument('--count', type=int, default=1_000_000); ap.add_argument('--start', type=int, default=0); ap.add_argument('--job-nonces', type=int, default=1 << 20) + ap = argparse.ArgumentParser(); ap.add_argument('--worker', required=True); ap.add_argument('--worker-arg', action='append', default=[]); ap.add_argument('--pack', default='') + ap.add_argument('--reference', default=''); ap.add_argument('--count', type=int, default=1_000_000); ap.add_argument('--start', type=int, default=0); ap.add_argument('--job-nonces', type=int, default=1 << 20) ap.add_argument('--prehash', default='00' * 31 + '01'); ap.add_argument('--manifest', default=''); ap.add_argument('--out', required=True) - a = ap.parse_args(); ev, rc = run(a) + ap.add_argument('--job-context', default=''); ap.add_argument('--phase', type=int, default=0) + a = ap.parse_args() + if a.job_context and not a.phase: ap.error('--job-context needs --phase 1|2|3') + if not a.job_context and not (a.pack and a.reference): ap.error('--pack and --reference, or --job-context with --phase') + ev, rc = run(a) os.makedirs(os.path.dirname(os.path.abspath(a.out)), exist_ok=True); json.dump(ev, open(a.out, 'w'), indent=2) + if 'error' in ev: print(f"p01-vectors: ERROR: {ev['error']} -> {a.out}"); sys.exit(rc) print(f"p01-vectors: {ev.get('verdict', 'ERROR')}: answered {ev.get('answered')} agree {ev.get('agree')} disagree {ev.get('disagree')} missing {ev.get('missing')} in {ev.get('seconds')} s -> {a.out}") sys.exit(rc) From 1458a5e8282c44e57cf9cd2e07d9a6ec8db80329 Mon Sep 17 00:00:00 2001 From: igneum-labs <337424239+igneum-labs@users.noreply.github.com> Date: Thu, 8 Oct 2026 20:50:37 +0000 Subject: [PATCH 2/4] same-work: the two job contexts (01 the frozen object 0x4de7b836cc40a4ea, 02 the chain-seed object 0x2a1d6caab4c24564) as read back on build-1 at 21:49 UK Co-Authored-By: Claude Fable 5.1 --- .../same-work-20261008-01/job-context.json | 75 +++++++++++++++++++ .../same-work-20261008-02/job-context.json | 75 +++++++++++++++++++ 2 files changed, 150 insertions(+) create mode 100644 docs/analysis/class-v6/same-work/same-work-20261008-01/job-context.json create mode 100644 docs/analysis/class-v6/same-work/same-work-20261008-02/job-context.json diff --git a/docs/analysis/class-v6/same-work/same-work-20261008-01/job-context.json b/docs/analysis/class-v6/same-work/same-work-20261008-01/job-context.json new file mode 100644 index 000000000..03ac7c918 --- /dev/null +++ b/docs/analysis/class-v6/same-work/same-work-20261008-01/job-context.json @@ -0,0 +1,75 @@ +{ + "format": "igneum-same-work-job-context-1", + "spec": "docs/plans/igneum-2.0-same-work-test.md (F03, Review B); the driver tools/ci/p01-vectors.py --job-context --phase 1|2|3", + "class": "v6", + "generator": 6, + "load_class": "mx8+sh256x27+state+reg64c+fold+rw", + "era": "0:edc4fa844da9dc98d37e965176f6558a31560e40502ab3ae5491b21aaaabfb07", + "era_seed_bytes": "edc4fa844da9dc98d37e965176f6558a31560e40502ab3ae5491b21aaaabfb07", + "era_widths": 4, + "generator_tree": "class-v6 1a938abe4 (igneum-pow built on build-4 at /srv/builds/igneum-wt-same-work-v6/igneum-pow, binary sha256 0d3f3fca713b10a3...)", + "state_stream": { + "path": "build-4:/srv/builds/v6-census/packs/node1-state.igsd1", + "chain_block": 159357, + "block_hash": "af89be5ddbadb6f6b4aee28ac8f249713be5d4c12621e3cea7f83ceada3c66b3", + "root": "1c583d352bb9c75a06dadb8d82d42836ebe8afa82d0b413be87bf921741f1526", + "records": 93, + "leaves": 93 + }, + "day": { + "D": { + "index": 20730, + "bytes": "69676e65756d2d6461792ffa50000000000000" + }, + "D1": { + "index": 20731, + "bytes": "69676e65756d2d6461792ffb50000000000000" + } + }, + "day_rule": "day bytes = 'igneum-day/' || day_le64 (igneum_pow::bind::day_bytes); D is the frozen pack's day index 20730, D+1 the next index 20731: the dataset-day rotation (infra/fast-time/override-60x.json, pow_day_ms 1440000) changes the day bytes and the dataset only; the program id is the same on both days", + "prehash": "0000000000000000000000000000000000000000000000000000000000000001", + "range_log2": 20, + "phases": { + "1": [ + 0, + 1048576 + ], + "2": [ + 1048576, + 2097152 + ], + "3": [ + 2097152, + 3145728 + ] + }, + "boundary_nonce": 1572864, + "boundary_rule": "the midpoint of phase 2 (2^20 + 2^19 = 1572864, 32-aligned for the workers): under the 60x clock the day switches every 1,440,000 ms and phase 2 is the engine's window across one switch; every reader switches program and dataset at this nonce; the boundary block is the last 2^12 nonces of day D [1568768, 1572864) and the first 2^12 of day D+1 [1572864, 1576960)", + "manifest": "c30ab32c", + "manifest_note": "packaging/release-manifest.json on release-2.0.1 c30ab32c (the F03 R01 record, node 7cfa422a); the pool kit is release-2.0.2 f3e99e9c whose manifest file carries the same 2.0.1 text; the kit's node enum ends at V5, so a class=v6 job line is unnameable by it (the pool lane's read-back, 22:0x UK)", + "references": { + "D": "references/ref-D.txt", + "D1": "references/ref-D1.txt" + }, + "reference_recipe": "igneum-pow hash-bound --epoch-hex --day-hex --class mx8+sh256x27+state+reg64c+fold+rw --era 0:edc4fa844da9dc98d37e965176f6558a31560e40502ab3ae5491b21aaaabfb07 --era-widths 4 --state node1-state.igsd1 --prehash 00..01 --nonce --count on build-4 with the class-v6 1a938abe4 binary; ref-D covers [0, 1572864), ref-D1 covers [1572864, 3145728)", + "readers": { + "cpu_reference": "the reference files themselves (igneum-pow hash-bound, build-4)", + "cuda": "the kit worker igneum-worker-cuda gen 6 (sha256 804a6f7f...) --serve on packs.D, driven by the driver (prepare of packs.D1 before phase 2)", + "opencl": "igneum-worker-opencl --serve, PC 1 RX 7600, the morning (08:30 UK)", + "metal": "the mini's worker, the morning (08:30 UK)", + "node": "igneum-miner --recheck-vectors on a branch off class-v6-node-review e8773ff5 (IgneumEngine::epoch_for then hash_bound per nonce)", + "pool": "igneum-pool recheck --job-context (the member-side share verifier); on the 2.0.2 kit BLOCKED by its V5 pins, the D1 pairing against class-v6-node-review e8773ff5 a separate labelled row" + }, + "evidence_shape": "the driver's JSON: agree, disagree, missing, the first ten disagreements, answered, segments (program id and day bytes per segment), boundary (phase 2: nonce, ids and day bytes either side, the hashes and references either side, switched), prepare_line, manifest_sha, verdict", + "job_line": "job ffffffffffffffff class=v6 era=edc4fa844da9dc98d37e965176f6558a31560e40502ab3ae5491b21aaaabfb07", + "run_id": "same-work-20261008-01", + "object": "the frozen class v6 object: pack hl-v6-all (tgz sha256 9131431015e102f4b2f545e1e56e7e2271b0e805568682200113f749709858b1, re-exported byte for byte from class-v6 1a938abe4 on build-4 at 21:44 UK), program id 0x4de7b836cc40a4ea, generator 6, epoch seed edc4fa844da9dc98d37e965176f6558a31560e40502ab3ae5491b21aaaabfb07 (the genesis seeds) over the node1 state stream", + "object_id": "0x4de7b836cc40a4ea", + "epoch_seed_bytes": "edc4fa844da9dc98d37e965176f6558a31560e40502ab3ae5491b21aaaabfb07", + "packs": { + "D": "packs/hl-v6-all", + "D1": "packs/hl-v6-all-d20731" + }, + "pairing_note": "the node engine refuses this pair: IgneumEngine::epoch_for's class v5 check wants the state stream's block (af89be5d...) to equal the epoch seed (edc4fa84...), so the node and pool readers cannot run it (the node lane's program-id read-back, 21:5x UK); this context is the CUDA and CPU row only and is never counted as same-work (the coordinator's ruling, 22:0x UK); the same-work run is same-work-20261008-02", + "written": "2026-10-08 22:1x UK by the same-work hand (worktree same-work-harness)" +} \ No newline at end of file diff --git a/docs/analysis/class-v6/same-work/same-work-20261008-02/job-context.json b/docs/analysis/class-v6/same-work/same-work-20261008-02/job-context.json new file mode 100644 index 000000000..3d07deb62 --- /dev/null +++ b/docs/analysis/class-v6/same-work/same-work-20261008-02/job-context.json @@ -0,0 +1,75 @@ +{ + "format": "igneum-same-work-job-context-1", + "spec": "docs/plans/igneum-2.0-same-work-test.md (F03, Review B); the driver tools/ci/p01-vectors.py --job-context --phase 1|2|3", + "class": "v6", + "generator": 6, + "load_class": "mx8+sh256x27+state+reg64c+fold+rw", + "era": "0:edc4fa844da9dc98d37e965176f6558a31560e40502ab3ae5491b21aaaabfb07", + "era_seed_bytes": "edc4fa844da9dc98d37e965176f6558a31560e40502ab3ae5491b21aaaabfb07", + "era_widths": 4, + "generator_tree": "class-v6 1a938abe4 (igneum-pow built on build-4 at /srv/builds/igneum-wt-same-work-v6/igneum-pow, binary sha256 0d3f3fca713b10a3...)", + "state_stream": { + "path": "build-4:/srv/builds/v6-census/packs/node1-state.igsd1", + "chain_block": 159357, + "block_hash": "af89be5ddbadb6f6b4aee28ac8f249713be5d4c12621e3cea7f83ceada3c66b3", + "root": "1c583d352bb9c75a06dadb8d82d42836ebe8afa82d0b413be87bf921741f1526", + "records": 93, + "leaves": 93 + }, + "day": { + "D": { + "index": 20730, + "bytes": "69676e65756d2d6461792ffa50000000000000" + }, + "D1": { + "index": 20731, + "bytes": "69676e65756d2d6461792ffb50000000000000" + } + }, + "day_rule": "day bytes = 'igneum-day/' || day_le64 (igneum_pow::bind::day_bytes); D is the frozen pack's day index 20730, D+1 the next index 20731: the dataset-day rotation (infra/fast-time/override-60x.json, pow_day_ms 1440000) changes the day bytes and the dataset only; the program id is the same on both days", + "prehash": "0000000000000000000000000000000000000000000000000000000000000001", + "range_log2": 20, + "phases": { + "1": [ + 0, + 1048576 + ], + "2": [ + 1048576, + 2097152 + ], + "3": [ + 2097152, + 3145728 + ] + }, + "boundary_nonce": 1572864, + "boundary_rule": "the midpoint of phase 2 (2^20 + 2^19 = 1572864, 32-aligned for the workers): under the 60x clock the day switches every 1,440,000 ms and phase 2 is the engine's window across one switch; every reader switches program and dataset at this nonce; the boundary block is the last 2^12 nonces of day D [1568768, 1572864) and the first 2^12 of day D+1 [1572864, 1576960)", + "manifest": "c30ab32c", + "manifest_note": "packaging/release-manifest.json on release-2.0.1 c30ab32c (the F03 R01 record, node 7cfa422a); the pool kit is release-2.0.2 f3e99e9c whose manifest file carries the same 2.0.1 text; the kit's node enum ends at V5, so a class=v6 job line is unnameable by it (the pool lane's read-back, 22:0x UK)", + "references": { + "D": "references/ref-D.txt", + "D1": "references/ref-D1.txt" + }, + "reference_recipe": "igneum-pow hash-bound --epoch-hex --day-hex --class mx8+sh256x27+state+reg64c+fold+rw --era 0:edc4fa844da9dc98d37e965176f6558a31560e40502ab3ae5491b21aaaabfb07 --era-widths 4 --state node1-state.igsd1 --prehash 00..01 --nonce --count on build-4 with the class-v6 1a938abe4 binary; ref-D covers [0, 1572864), ref-D1 covers [1572864, 3145728)", + "readers": { + "cpu_reference": "the reference files themselves (igneum-pow hash-bound, build-4)", + "cuda": "the kit worker igneum-worker-cuda gen 6 (sha256 804a6f7f...) --serve on packs.D, driven by the driver (prepare of packs.D1 before phase 2)", + "opencl": "igneum-worker-opencl --serve, PC 1 RX 7600, the morning (08:30 UK)", + "metal": "the mini's worker, the morning (08:30 UK)", + "node": "igneum-miner --recheck-vectors on a branch off class-v6-node-review e8773ff5 (IgneumEngine::epoch_for then hash_bound per nonce)", + "pool": "igneum-pool recheck --job-context (the member-side share verifier); on the 2.0.2 kit BLOCKED by its V5 pins, the D1 pairing against class-v6-node-review e8773ff5 a separate labelled row" + }, + "evidence_shape": "the driver's JSON: agree, disagree, missing, the first ten disagreements, answered, segments (program id and day bytes per segment), boundary (phase 2: nonce, ids and day bytes either side, the hashes and references either side, switched), prepare_line, manifest_sha, verdict", + "job_line": "job ffffffffffffffff class=v6 era=edc4fa844da9dc98d37e965176f6558a31560e40502ab3ae5491b21aaaabfb07", + "run_id": "same-work-20261008-02", + "object": "the chain-seed class v6 object: epoch seed af89be5ddbadb6f6b4aee28ac8f249713be5d4c12621e3cea7f83ceada3c66b3 (the node1 state stream's own block hash, the pair the engine accepts) with the genesis era seed, class v6 generator 6, program id 0x2a1d6caab4c24564 (the id the node lane drew on class-v6-node-review; the export with era 0:af89be5d... draws 0x442a1691b3e3507f and is not it), packs exported from class-v6 1a938abe4 on build-4 at 21:48 UK", + "object_id": "0x2a1d6caab4c24564", + "epoch_seed_bytes": "af89be5ddbadb6f6b4aee28ac8f249713be5d4c12621e3cea7f83ceada3c66b3", + "packs": { + "D": "packs/chain-seed-d20730", + "D1": "packs/chain-seed-d20731" + }, + "pairing_note": "every reader runs this context (the coordinator's ruling, 22:0x UK: the same-work test's meaning is six readers on one context); the frozen-object context 01 is the CUDA and CPU-only row", + "written": "2026-10-08 22:1x UK by the same-work hand (worktree same-work-harness)" +} \ No newline at end of file From 3bd6d19c449f795eccc08c568c0b4cfcf4f6d988 Mon Sep 17 00:00:00 2001 From: igneum-labs <337424239+igneum-labs@users.noreply.github.com> Date: Thu, 8 Oct 2026 21:21:17 +0000 Subject: [PATCH 3/4] same-work: context 03 (the live chain's class v5 object 0x81fbfa3aa413173f at epoch 2) as read back on build-1 Co-Authored-By: Claude Fable 5.1 --- .../same-work-20261008-03/job-context.json | 78 +++++++++++++++++++ 1 file changed, 78 insertions(+) create mode 100644 docs/analysis/class-v6/same-work/same-work-20261008-03/job-context.json diff --git a/docs/analysis/class-v6/same-work/same-work-20261008-03/job-context.json b/docs/analysis/class-v6/same-work/same-work-20261008-03/job-context.json new file mode 100644 index 000000000..1e24488e0 --- /dev/null +++ b/docs/analysis/class-v6/same-work/same-work-20261008-03/job-context.json @@ -0,0 +1,78 @@ +{ + "format": "igneum-same-work-job-context-1", + "spec": "docs/plans/igneum-2.0-same-work-test.md (F03, Review B); the driver tools/ci/p01-vectors.py --job-context --phase 1|2|3", + "class": "v5", + "generator": 5, + "load_class": "mx8-era+sh256x27+state (class v5, --program-class v5)", + "era": "0:7c36b83374a673e990213be462509dcb08bcfc85144306aa9517cf3ad66faf6e", + "era_seed_bytes": "7c36b83374a673e990213be462509dcb08bcfc85144306aa9517cf3ad66faf6e", + "era_widths": 4, + "generator_tree": "release-2.0.1 c30ab32c (igneum-pow at the class v5 freeze 1c420786, fingerprint cbc5bd0a), built on build-4 at /srv/builds/igneum-wt-same-work-v5/igneum-pow", + "state_stream": { + "path": "state-epoch2.igsd1 (beside this file; from build-1's seed EVM RPC 127.0.0.1:27810 igneum_getPowStateLeaves for the seed block; the hand 26870 answered \"no published state stream\" for it at 22:18 UK)", + "chain_block": 3423, + "block_hash": "3c3fab434f7fd894ce6db0b09f298c3865726253e4fc68fd77acd163ccea8221", + "root": "0xf798d1d89ee4de62...", + "records": 224, + "bytes": 21132, + "sha256": "f36e6bbab71dc8b049fff052d0895bc4dd1e3f245779e82968fcf5b42535dee1" + }, + "day": { + "D": { + "index": 20734, + "bytes": "69676e65756d2d6461792ffe50000000000000" + }, + "D1": { + "index": 20735, + "bytes": "69676e65756d2d6461792fff50000000000000" + } + }, + "day_rule": "day bytes = 'igneum-day/' || day_le64 (igneum_pow::bind::day_bytes); D is the frozen pack's day index 20730, D+1 the next index 20731: the dataset-day rotation (infra/fast-time/override-60x.json, pow_day_ms 1440000) changes the day bytes and the dataset only; the program id is the same on both days", + "prehash": "0000000000000000000000000000000000000000000000000000000000000001", + "range_log2": 20, + "phases": { + "1": [ + 0, + 1048576 + ], + "2": [ + 1048576, + 2097152 + ], + "3": [ + 2097152, + 3145728 + ] + }, + "boundary_nonce": 1572864, + "boundary_rule": "the midpoint of phase 2 (2^20 + 2^19 = 1572864, 32-aligned for the workers): under the 60x clock the day switches every 1,440,000 ms and phase 2 is the engine's window across one switch; every reader switches program and dataset at this nonce; the boundary block is the last 2^12 nonces of day D [1568768, 1572864) and the first 2^12 of day D+1 [1572864, 1576960)", + "manifest": "c30ab32c", + "manifest_note": "packaging/release-manifest.json on release-2.0.1 c30ab32c (the F03 R01 record, node 7cfa422a); the pool kit is release-2.0.2 f3e99e9c whose manifest file carries the same 2.0.1 text; the kit's node enum ends at V5, so a class=v6 job line is unnameable by it (the pool lane's read-back, 22:0x UK)", + "references": { + "D": "references/ref-D.txt", + "D1": "references/ref-D1.txt" + }, + "reference_recipe": "igneum-pow hash-bound --epoch-hex 3c3fab434f7fd894ce6db0b09f298c3865726253e4fc68fd77acd163ccea8221 --day-hex --program-class v5 --era-hex 7c36b83374a673e990213be462509dcb08bcfc85144306aa9517cf3ad66faf6e --state state-epoch2.igsd1 --prehash 00..01 --nonce --count on build-4 with release-2.0.1's binary 7ba781db...; ref-D covers [0, 1572864), ref-D1 [1572864, 3145728)", + "readers": { + "cpu_reference": "the reference files themselves (igneum-pow hash-bound, build-4)", + "cuda": "the kit worker igneum-worker-cuda 9bfcf728 (generation 5) --serve on packs.D, driven by the driver (prepare of packs.D1 before phase 2)", + "opencl": "igneum-worker-opencl --serve, PC 1 RX 7600, the morning (08:30 UK)", + "metal": "the mini's worker, the morning (08:30 UK)", + "node": "igneum-miner --recheck-vectors on the release line's engine (class v5 by construction); until the subcommand is on a release-line branch the row reads from same-work-node cc23f9bd labelled as such", + "pool": "igneum-pool recheck on the 2.0.2 kit as pinned (class v5 is nameable by its node)" + }, + "evidence_shape": "the driver's JSON: agree, disagree, missing, the first ten disagreements, answered, segments (program id and day bytes per segment), boundary (phase 2: nonce, ids and day bytes either side, the hashes and references either side, switched), prepare_line, manifest_sha, verdict", + "job_line": "job ffffffffffffffff class=v5 era=7c36b83374a673e990213be462509dcb08bcfc85144306aa9517cf3ad66faf6e", + "run_id": "same-work-20261008-03", + "object": "the live chain half: igneum-devnet-4 class v5 object at epoch 2, program id 0x81fbfa3aa413173f, epoch seed 3c3fab434f7fd894ce6db0b09f298c3865726253e4fc68fd77acd163ccea8221 (the epoch-2 seed block, chain block 3423, common to every tonight's chain: the split came after it), day 20734, era 0 seed 7c36b83374a673e990213be462509dcb08bcfc85144306aa9517cf3ad66faf6e (class v5 reads no era: the id is the same under era zero, both read), generator 5, on release-2.0.1's igneum-pow (class v5 freeze 1c420786; binary sha256 7ba781db08525637... built on build-4 from c30ab32c)", + "object_id": "0x81fbfa3aa413173f", + "epoch_seed_bytes": "3c3fab434f7fd894ce6db0b09f298c3865726253e4fc68fd77acd163ccea8221", + "packs": { + "D": "packs/v5-epoch2-d20734", + "D1": "packs/v5-epoch2-d20735" + }, + "pairing_note": "the coordinator's third row (22:1x UK): the same-work test's live-chain half; the node and pool readers run it on their release-line engines; CPU and CUDA cells by 06:00 UK, node and pool NOT RUN with a 08:30 UK clock if the hours run out", + "written": "2026-10-08 22:2x UK by the same-work hand (worktree same-work-harness)", + "genesis_day_index": 20734, + "witness": "igneum-miner program-id --epoch-hex --era-hex --day 20734 --class v5 --state state-epoch2.igsd1 reads \"class v5 attempt 0 id 81fbfa3aa413173f\" under era 7c36b833... and under era 00..00 alike (the miner at same-work-node cc23f9bd on build-2, the class v5 engine path; the 2.0.1 pair's miner ef0f2ed8 on build-1 has no program-id subcommand); the placed (c) pair's read on the seed's stream gave the same id (the node lane, 22:33 UK); build-1's seed is a dead fork since 21:34 UK (the devnet-4 split at the epoch-3 cut) and epoch 2's object is unaffected" +} \ No newline at end of file From f7684b6f8342d587485847332fa0c622b01c31d6 Mon Sep 17 00:00:00 2001 From: igneum-labs <337424239+igneum-labs@users.noreply.github.com> Date: Thu, 8 Oct 2026 21:28:17 +0000 Subject: [PATCH 4/4] same-work: the three batches (01 the frozen object, 02 the chain-seed object with the node cell PASS x3, 03 the live class v5 object) recorded through test-record; every cell labelled on an island, not a network Co-Authored-By: Claude Fable 5.1 --- docs/plans/igneum-2.0-test-registry.json | 148 ++++++++++++++------ tools/ci/batches/same-work-20261008-01.json | 37 +++++ tools/ci/batches/same-work-20261008-02.json | 50 +++++++ tools/ci/batches/same-work-20261008-03.json | 50 +++++++ 4 files changed, 240 insertions(+), 45 deletions(-) create mode 100644 tools/ci/batches/same-work-20261008-01.json create mode 100644 tools/ci/batches/same-work-20261008-02.json create mode 100644 tools/ci/batches/same-work-20261008-03.json diff --git a/docs/plans/igneum-2.0-test-registry.json b/docs/plans/igneum-2.0-test-registry.json index dc14b7dce..5f90f1c40 100644 --- a/docs/plans/igneum-2.0-test-registry.json +++ b/docs/plans/igneum-2.0-test-registry.json @@ -1329,30 +1329,30 @@ "manual_page": 24, "owner_lane": "hash lane (a690540514aa453d7)", "run_status": "NOT RUN", - "evidence_path": "docs/analysis/review-2026-10-08-b/f10/emu-test.log; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-5090-hl-v5-win.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-4090-hl-v5-win.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-3090-hl-v5-win.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-5090-hl-v6-all.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-4090-hl-v6-all.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-3090-hl-v6-all.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-5090-hl-v6-foldrw.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-4090-hl-v6-foldrw.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-3090-hl-v6-foldrw.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-5090-hl-v6-all-nowin.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-4090-hl-v6-all-nowin.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-3090-hl-v6-all-nowin.json", - "run_id": "p01-20261008-01", - "updated": "2026-10-08T20:10:24.686Z", + "evidence_path": "docs/analysis/review-2026-10-08-b/f10/emu-test.log; build-1:/srv/artefacts/tas/same-work-20261008-01/job-context.json; build-1:/srv/artefacts/tas/same-work-20261008-01/references/ref-D.txt; build-1:/srv/artefacts/tas/same-work-20261008-01/references/ref-D1.txt", + "run_id": "same-work-20261008-01", + "updated": "2026-10-08T21:27:53.422Z", "evidence_record": { "requirement_id": "POW-01", "decision": "NOT RUN", "method": "GPU", "cell": "harness:p01-vectors", - "manifest_sha": "417c4a57", - "run_id": "p01-20261008-01", - "evidence": "build-1:/srv/artefacts/p01/p01-20261008-01/cuda-5090-hl-v5-win.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-4090-hl-v5-win.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-3090-hl-v5-win.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-5090-hl-v6-all.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-4090-hl-v6-all.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-3090-hl-v6-all.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-5090-hl-v6-foldrw.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-4090-hl-v6-foldrw.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-3090-hl-v6-foldrw.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-5090-hl-v6-all-nowin.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-4090-hl-v6-all-nowin.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-3090-hl-v6-all-nowin.json", + "manifest_sha": "c30ab32c", + "run_id": "same-work-20261008-01", + "evidence": "build-1:/srv/artefacts/tas/same-work-20261008-01/job-context.json; build-1:/srv/artefacts/tas/same-work-20261008-01/references/ref-D.txt; build-1:/srv/artefacts/tas/same-work-20261008-01/references/ref-D1.txt", "in_progress": false, "coverage": "the million-vector campaign per backend per pack, bit-for-bit; PASS only when every supported backend reads a million vectors with zero disagreement; the malformed-input half is harness:parser-malformed", "release_identity": { - "commit": "417c4a57 (the node pin at the kit's cut); the kit packs-class-v6-20261008T162324Z.zip 098e64c3…; the worker igneum-worker-cuda 9bfcf728", + "commit": "c30ab32c; the CPU reference class-v6 1a938abe4; the CUDA reader the kit's gen 6 worker 804a6f7f", "lockfile": "", - "binary": "bin/linux/igneum-worker-cuda (the kit's)", - "network_object": "the class v5 freeze 1c420786, pack hl-v5-win e3da3669 id 0x6554474f410f36f3", - "activation": "igneum-devnet-4 object be5f4068", + "binary": "igneum-pow sha256 0d3f3fca...; igneum-worker-cuda sha256 804a6f7f...", + "network_object": "the frozen class v6 object: pack hl-v6-all (tgz sha256 9131431015e102f4..., re-exported byte for byte from class-v6 1a938abe4 on build-4 at 21:44 UK, every file's sha256 equal), id 0x4de7b836cc40a4ea, epoch seed edc4fa84... (the genesis seeds) over the node1 state stream", + "activation": "none (a re-check of hashes against one job context, no chain state changes)", "profile_hashes": "" }, - "claim_impact": "POW-01's CUDA half on the class v5 object and all three class v6 D1 candidates: a million nonces agree bit-for-bit with the CPU reference on three CUDA generations each; OpenCL and Metal remain", + "claim_impact": "POW-01's CUDA half across a dataset-day switch on the frozen object: CUDA against the CPU reference bit for bit on three ranges with the day switch at nonce 1572864. NOT same-work evidence: the node engine refuses this seed/stream pair (IgneumEngine::epoch_for's class v5 check wants the stream's block af89be5d... to equal the epoch seed edc4fa84...), so the node and pool readers cannot read it; the coordinator's ruling 22:0x UK keeps it as the CUDA and CPU-only row", "reviewer": "", - "at": "2026-10-08T20:10:24.686Z" + "at": "2026-10-08T21:27:53.422Z" }, "in_progress_since": "2026-10-08T20:07:26.255Z", "approvals": { @@ -1392,22 +1392,22 @@ "decision": "NOT RUN", "method": "GPU", "cell": "harness:p01-vectors", - "manifest_sha": "417c4a57", - "run_id": "p01-20261008-01", - "evidence": "build-1:/srv/artefacts/p01/p01-20261008-01/cuda-5090-hl-v5-win.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-4090-hl-v5-win.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-3090-hl-v5-win.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-5090-hl-v6-all.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-4090-hl-v6-all.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-3090-hl-v6-all.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-5090-hl-v6-foldrw.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-4090-hl-v6-foldrw.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-3090-hl-v6-foldrw.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-5090-hl-v6-all-nowin.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-4090-hl-v6-all-nowin.json; build-1:/srv/artefacts/p01/p01-20261008-01/cuda-3090-hl-v6-all-nowin.json", + "manifest_sha": "c30ab32c", + "run_id": "same-work-20261008-01", + "evidence": "build-1:/srv/artefacts/tas/same-work-20261008-01/job-context.json; build-1:/srv/artefacts/tas/same-work-20261008-01/references/ref-D.txt; build-1:/srv/artefacts/tas/same-work-20261008-01/references/ref-D1.txt", "in_progress": false, "coverage": "the million-vector campaign per backend per pack, bit-for-bit; PASS only when every supported backend reads a million vectors with zero disagreement; the malformed-input half is harness:parser-malformed", "release_identity": { - "commit": "417c4a57 (the node pin at the kit's cut); the kit packs-class-v6-20261008T162324Z.zip 098e64c3…; the worker igneum-worker-cuda 9bfcf728", + "commit": "c30ab32c; the CPU reference class-v6 1a938abe4; the CUDA reader the kit's gen 6 worker 804a6f7f", "lockfile": "", - "binary": "bin/linux/igneum-worker-cuda (the kit's)", - "network_object": "the class v5 freeze 1c420786, pack hl-v5-win e3da3669 id 0x6554474f410f36f3", - "activation": "igneum-devnet-4 object be5f4068", + "binary": "igneum-pow sha256 0d3f3fca...; igneum-worker-cuda sha256 804a6f7f...", + "network_object": "the frozen class v6 object: pack hl-v6-all (tgz sha256 9131431015e102f4..., re-exported byte for byte from class-v6 1a938abe4 on build-4 at 21:44 UK, every file's sha256 equal), id 0x4de7b836cc40a4ea, epoch seed edc4fa84... (the genesis seeds) over the node1 state stream", + "activation": "none (a re-check of hashes against one job context, no chain state changes)", "profile_hashes": "" }, - "claim_impact": "POW-01's CUDA half on the class v5 object and all three class v6 D1 candidates: a million nonces agree bit-for-bit with the CPU reference on three CUDA generations each; OpenCL and Metal remain", + "claim_impact": "POW-01's CUDA half across a dataset-day switch on the frozen object: CUDA against the CPU reference bit for bit on three ranges with the day switch at nonce 1572864. NOT same-work evidence: the node engine refuses this seed/stream pair (IgneumEngine::epoch_for's class v5 check wants the stream's block af89be5d... to equal the epoch seed edc4fa84...), so the node and pool readers cannot read it; the coordinator's ruling 22:0x UK keeps it as the CUDA and CPU-only row", "reviewer": "", - "at": "2026-10-08T20:10:24.686Z" + "at": "2026-10-08T21:27:53.422Z" } } }, @@ -12096,23 +12096,28 @@ "POW-01", "ROT-02" ], - "updated": "2026-10-08T20:10:24.556Z", + "updated": "2026-10-08T21:27:53.523Z", "evidence_record": { - "reason": "R2-F03 (P0, the external review): the regression's harness is the owner lane's (CI steward, hash lane (ProgramClass::V6 on freeze), pool lane); not yet named in the map", - "at": "2026-10-08T20:10:24.556Z", - "method": "static", "requirement_id": "R2-F03-R02", "decision": "NOT RUN", - "reviewer": "", - "claim_impact": "", + "method": "GPU", + "cell": "harness:same-work", + "manifest_sha": "c30ab32c", + "run_id": "same-work-20261008-03", + "evidence": "build-1:/srv/artefacts/tas/same-work-20261008-03/job-context.json; build-1:/srv/artefacts/tas/same-work-20261008-03/state-epoch2.igsd1", + "in_progress": false, + "coverage": "partial until every reader has run: bit-for-bit agreement per nonce across node, CPU reference, CUDA, OpenCL, Metal and pool on one job context", "release_identity": { - "commit": "", + "commit": "c30ab32c (release-2.0.1; the class v5 freeze 1c420786, fingerprint cbc5bd0a); the CUDA reader the kit's gen 5 worker 9bfcf728", "lockfile": "", - "binary": "", - "network_object": "", - "activation": "", + "binary": "igneum-pow sha256 7ba781db... (release-2.0.1 c30ab32c, built on build-4); igneum-worker-cuda gen 5 sha256 9bfcf728...", + "network_object": "igneum-devnet-4's class v5 object at epoch 2: id 0x81fbfa3aa413173f, epoch seed 3c3fab43... (the epoch-2 seed block, chain block 3423, common to every chain tonight: the split came after it), day 20734, era 0 seed 7c36b833... (class v5 reads no era; the id is the same under era zero), state stream state-epoch2.igsd1 (sha256 f36e6bba..., 21,132 bytes, 224 records, root 0xf798d1d8...) pulled at 22:18 UK from build-1's seed EVM RPC 27810", + "activation": "none (a re-check of hashes against one job context, no chain state changes)", "profile_hashes": "" - } + }, + "claim_impact": "the same-work test's live-chain half (the coordinator's third row, 22:1x UK): the readers on the chain's own class v5 object at epoch 2 across the day switch 20734 to 20735; the node and pool readers run it on their release-line engines, the row those two can PASS without the class v6 branch", + "reviewer": "", + "at": "2026-10-08T21:27:53.523Z" }, "evidence_records": { "record": { @@ -12132,6 +12137,28 @@ "profile_hashes": "" }, "in_progress": false + }, + "harness:same-work": { + "requirement_id": "R2-F03-R02", + "decision": "NOT RUN", + "method": "GPU", + "cell": "harness:same-work", + "manifest_sha": "c30ab32c", + "run_id": "same-work-20261008-03", + "evidence": "build-1:/srv/artefacts/tas/same-work-20261008-03/job-context.json; build-1:/srv/artefacts/tas/same-work-20261008-03/state-epoch2.igsd1", + "in_progress": false, + "coverage": "partial until every reader has run: bit-for-bit agreement per nonce across node, CPU reference, CUDA, OpenCL, Metal and pool on one job context", + "release_identity": { + "commit": "c30ab32c (release-2.0.1; the class v5 freeze 1c420786, fingerprint cbc5bd0a); the CUDA reader the kit's gen 5 worker 9bfcf728", + "lockfile": "", + "binary": "igneum-pow sha256 7ba781db... (release-2.0.1 c30ab32c, built on build-4); igneum-worker-cuda gen 5 sha256 9bfcf728...", + "network_object": "igneum-devnet-4's class v5 object at epoch 2: id 0x81fbfa3aa413173f, epoch seed 3c3fab43... (the epoch-2 seed block, chain block 3423, common to every chain tonight: the split came after it), day 20734, era 0 seed 7c36b833... (class v5 reads no era; the id is the same under era zero), state stream state-epoch2.igsd1 (sha256 f36e6bba..., 21,132 bytes, 224 records, root 0xf798d1d8...) pulled at 22:18 UK from build-1's seed EVM RPC 27810", + "activation": "none (a re-check of hashes against one job context, no chain state changes)", + "profile_hashes": "" + }, + "claim_impact": "the same-work test's live-chain half (the coordinator's third row, 22:1x UK): the readers on the chain's own class v5 object at epoch 2 across the day switch 20734 to 20735; the node and pool readers run it on their release-line engines, the row those two can PASS without the class v6 branch", + "reviewer": "", + "at": "2026-10-08T21:27:53.523Z" } }, "approvals": { @@ -12139,7 +12166,9 @@ "implementation_complete": null, "evidence_reproduced": null, "claim_authorised": null - } + }, + "run_id": "same-work-20261008-03", + "evidence_path": "build-1:/srv/artefacts/tas/same-work-20261008-03/job-context.json; build-1:/srv/artefacts/tas/same-work-20261008-03/state-epoch2.igsd1" }, { "id": "R2-F03-R03", @@ -12172,23 +12201,28 @@ "POW-01", "ROT-02" ], - "updated": "2026-10-08T20:10:24.556Z", + "updated": "2026-10-08T21:27:53.523Z", "evidence_record": { - "reason": "R2-F03 (P0, the external review): the regression's harness is the owner lane's (CI steward, hash lane (ProgramClass::V6 on freeze), pool lane); not yet named in the map", - "at": "2026-10-08T20:10:24.556Z", - "method": "static", "requirement_id": "R2-F03-R03", "decision": "NOT RUN", - "reviewer": "", - "claim_impact": "", + "method": "GPU", + "cell": "harness:same-work", + "manifest_sha": "c30ab32c", + "run_id": "same-work-20261008-03", + "evidence": "build-1:/srv/artefacts/tas/same-work-20261008-03/job-context.json", + "in_progress": false, + "coverage": "partial: the day-boundary transition in phase 2 (the one transition every live network crosses hourly at 60x); a class rotation is the same test on a research object until a v6 floor is set", "release_identity": { - "commit": "", + "commit": "c30ab32c (release-2.0.1; the class v5 freeze 1c420786, fingerprint cbc5bd0a); the CUDA reader the kit's gen 5 worker 9bfcf728", "lockfile": "", - "binary": "", - "network_object": "", - "activation": "", + "binary": "igneum-pow sha256 7ba781db... (release-2.0.1 c30ab32c, built on build-4); igneum-worker-cuda gen 5 sha256 9bfcf728...", + "network_object": "igneum-devnet-4's class v5 object at epoch 2: id 0x81fbfa3aa413173f, epoch seed 3c3fab43... (the epoch-2 seed block, chain block 3423, common to every chain tonight: the split came after it), day 20734, era 0 seed 7c36b833... (class v5 reads no era; the id is the same under era zero), state stream state-epoch2.igsd1 (sha256 f36e6bba..., 21,132 bytes, 224 records, root 0xf798d1d8...) pulled at 22:18 UK from build-1's seed EVM RPC 27810", + "activation": "none (a re-check of hashes against one job context, no chain state changes)", "profile_hashes": "" - } + }, + "claim_impact": "the same-work test's live-chain half (the coordinator's third row, 22:1x UK): the readers on the chain's own class v5 object at epoch 2 across the day switch 20734 to 20735; the node and pool readers run it on their release-line engines, the row those two can PASS without the class v6 branch", + "reviewer": "", + "at": "2026-10-08T21:27:53.523Z" }, "evidence_records": { "record": { @@ -12208,6 +12242,28 @@ "profile_hashes": "" }, "in_progress": false + }, + "harness:same-work": { + "requirement_id": "R2-F03-R03", + "decision": "NOT RUN", + "method": "GPU", + "cell": "harness:same-work", + "manifest_sha": "c30ab32c", + "run_id": "same-work-20261008-03", + "evidence": "build-1:/srv/artefacts/tas/same-work-20261008-03/job-context.json", + "in_progress": false, + "coverage": "partial: the day-boundary transition in phase 2 (the one transition every live network crosses hourly at 60x); a class rotation is the same test on a research object until a v6 floor is set", + "release_identity": { + "commit": "c30ab32c (release-2.0.1; the class v5 freeze 1c420786, fingerprint cbc5bd0a); the CUDA reader the kit's gen 5 worker 9bfcf728", + "lockfile": "", + "binary": "igneum-pow sha256 7ba781db... (release-2.0.1 c30ab32c, built on build-4); igneum-worker-cuda gen 5 sha256 9bfcf728...", + "network_object": "igneum-devnet-4's class v5 object at epoch 2: id 0x81fbfa3aa413173f, epoch seed 3c3fab43... (the epoch-2 seed block, chain block 3423, common to every chain tonight: the split came after it), day 20734, era 0 seed 7c36b833... (class v5 reads no era; the id is the same under era zero), state stream state-epoch2.igsd1 (sha256 f36e6bba..., 21,132 bytes, 224 records, root 0xf798d1d8...) pulled at 22:18 UK from build-1's seed EVM RPC 27810", + "activation": "none (a re-check of hashes against one job context, no chain state changes)", + "profile_hashes": "" + }, + "claim_impact": "the same-work test's live-chain half (the coordinator's third row, 22:1x UK): the readers on the chain's own class v5 object at epoch 2 across the day switch 20734 to 20735; the node and pool readers run it on their release-line engines, the row those two can PASS without the class v6 branch", + "reviewer": "", + "at": "2026-10-08T21:27:53.523Z" } }, "approvals": { @@ -12215,7 +12271,9 @@ "implementation_complete": null, "evidence_reproduced": null, "claim_authorised": null - } + }, + "run_id": "same-work-20261008-03", + "evidence_path": "build-1:/srv/artefacts/tas/same-work-20261008-03/job-context.json" }, { "id": "R2-F04-R01", diff --git a/tools/ci/batches/same-work-20261008-01.json b/tools/ci/batches/same-work-20261008-01.json new file mode 100644 index 000000000..d8db076bb --- /dev/null +++ b/tools/ci/batches/same-work-20261008-01.json @@ -0,0 +1,37 @@ +{ + "run_id": "same-work-20261008-01", + "manifest_sha": "c30ab32c", + "method": "GPU", + "evidence_dir": "build-1:/srv/artefacts/tas/same-work-20261008-01", + "boxes": [ + "build-4 (CPU reference)", + "tas-p01-5090", + "tas-p01-4090", + "tas-p01-3090" + ], + "release_identity": { + "lockfile": "", + "activation": "none (a re-check of hashes against one job context, no chain state changes)", + "profile_hashes": "", + "commit": "c30ab32c; the CPU reference class-v6 1a938abe4; the CUDA reader the kit's gen 6 worker 804a6f7f", + "binary": "igneum-pow sha256 0d3f3fca...; igneum-worker-cuda sha256 804a6f7f...", + "network_object": "the frozen class v6 object: pack hl-v6-all (tgz sha256 9131431015e102f4..., re-exported byte for byte from class-v6 1a938abe4 on build-4 at 21:44 UK, every file's sha256 equal), id 0x4de7b836cc40a4ea, epoch seed edc4fa84... (the genesis seeds) over the node1 state stream" + }, + "claim_impact": "POW-01's CUDA half across a dataset-day switch on the frozen object: CUDA against the CPU reference bit for bit on three ranges with the day switch at nonce 1572864. NOT same-work evidence: the node engine refuses this seed/stream pair (IgneumEngine::epoch_for's class v5 check wants the stream's block af89be5d... to equal the epoch seed edc4fa84...), so the node and pool readers cannot read it; the coordinator's ruling 22:0x UK keeps it as the CUDA and CPU-only row", + "network_label": "on an island, not a network", + "note": "Context 01 at build-1:/srv/artefacts/tas/same-work-20261008-01/job-context.json (sha256 d2540e02...). CPU reference: igneum-pow hash-bound (class-v6 1a938abe4, binary 0d3f3fca...) on build-4, 21:46 to 21:55 UK, ref-D c49fed11... over [0, 1572864), ref-D1 5ae1220d... over [1572864, 3145728); ref-D's first million lines equal the hash lane's P01 reference /srv/artefacts/packs/p01-vectors/hl-v6-all.txt byte for byte. The node1 state stream (block af89be5d...) was written on build-4 at 15:34 UK, before the 20:00 UK split; the cell carries the island label by main's 22:2x UK rule. CUDA: runs after context 02 on the three pods (the fleet lane's runner), evidence cuda--.json beside the context; in progress at the time of this record.", + "cells": [ + { + "cell": "harness:p01-vectors", + "cases": [ + "POW-01" + ], + "status": "NOT RUN", + "method": "GPU", + "evidence": "build-1:/srv/artefacts/tas/same-work-20261008-01/job-context.json; build-1:/srv/artefacts/tas/same-work-20261008-01/references/ref-D.txt; build-1:/srv/artefacts/tas/same-work-20261008-01/references/ref-D1.txt", + "note": "the CUDA reads on the frozen object across the day switch are running after context 02; CPU reference written and cross-checked against the hash lane's P01 file; in progress", + "network_label": "on an island, not a network", + "in_progress": true + } + ] +} \ No newline at end of file diff --git a/tools/ci/batches/same-work-20261008-02.json b/tools/ci/batches/same-work-20261008-02.json new file mode 100644 index 000000000..08a8dcc0d --- /dev/null +++ b/tools/ci/batches/same-work-20261008-02.json @@ -0,0 +1,50 @@ +{ + "run_id": "same-work-20261008-02", + "manifest_sha": "c30ab32c", + "method": "GPU", + "evidence_dir": "build-1:/srv/artefacts/tas/same-work-20261008-02", + "boxes": [ + "build-4 (CPU reference, pool D1 pairing)", + "build-2 (node reader)", + "tas-p01-5090", + "tas-p01-4090", + "tas-p01-3090" + ], + "release_identity": { + "lockfile": "", + "activation": "none (a re-check of hashes against one job context, no chain state changes)", + "profile_hashes": "", + "commit": "c30ab32c (packaging/release-manifest.json on release-2.0.1; node 7cfa422a); the readers: node same-work-node cc23f9bd (igneum-node, off class-v6-node-review e8773ff5, paired with class-v6 1a938abe4), CPU reference class-v6 1a938abe4, CUDA the kit's gen 6 worker 804a6f7f, pool pool-recheck-202 00c7e1db over class-v6-node-review e8773ff5", + "binary": "igneum-miner recheck-vectors sha256 9d563c41...; igneum-pow sha256 0d3f3fca...; igneum-worker-cuda sha256 804a6f7f...; igneum-pool sha256 b9fb3a60... (D1 pairing) and 2f6378e4... (kit)", + "network_object": "the chain-seed class v6 object: epoch seed af89be5d... (the node1 state stream's block 159357, root 1c583d35..., stream sha256 abb58003...) with the genesis era seed edc4fa84..., generator 6, id 0x2a1d6caab4c24564 (the hash lane's 22:00 UK ruling; their independent export hl-v6-all-cs a4742bfe... equals packs/chain-seed-d20730 file by file)" + }, + "claim_impact": "R2-F03-R02 and R03 on one job context (the chain-seed class v6 object) across the readers that can run it tonight: node, CPU reference, CUDA and pool on three phases with the dataset-day switch at nonce 1572864; PASS only when every reader agrees bit for bit on every nonce; Metal and OpenCL are the morning's", + "network_label": "on an island, not a network", + "note": "The same-work run (the coordinator's ruling 22:0x UK: six readers on one context; the frozen-object context 01 is the CUDA and CPU-only row). The node1 state stream (block af89be5d..., written on build-4 at 15:34 UK, before the 20:00 UK split) keys every item; every cell carries the island label by main's 22:2x UK rule. Day D = 20730 (bytes ...2ffa50), D+1 = 20731 (...2ffb50); phase 2 switches at 1572864 (the midpoint, 32-aligned); genesis day index 20730 and dataset 2^28 words for the engine's growth rule (doublings 0 on both days). CPU reference: igneum-pow hash-bound (class-v6 1a938abe4, binary 0d3f3fca...) on build-4, 21:48 to 21:57 UK, ref-D 7c7be9b5... over [0, 1572864), ref-D1 cad7849f... over [1572864, 3145728); the hash lane's independent million-nonce reference hl-v6-all-cs.txt (b77c61d8..., 22:03 UK) equals ref-D's first million lines byte for byte. Node reader: PASS on all three phases (22:17, 22:21, 22:25 UK; 1,048,576 agree each, 0 disagree, 0 missing; the boundary switched: d28fcfd70ba70a64 before, 45905ff3d608dc12 after, both equal to the reference; the program id unchanged across the day). Reader faults recorded, not disagreements: the node reader's first phase 1 at 22:10 UK read FAIL on every nonce with the program id equal because the standalone engine held the genesis day at 0 and the growth rule doubled the cache fourteen times (fixed at cc23f9bd: install_pow_genesis from the context and the pack, the live miner's own call); the pool lane's D1-pairing run at 22:17 UK hit the same class (its nonce 0 and 1 hashes equal the pre-fix node hashes byte for byte), fix sent 22:18 UK, rerun pending. The pool on the 2.0.2 kit as pinned (release-2.0.2 00c7e1db, node 7cfa422a) is BLOCKED: its node's ProgramClass enum ends at V5, so a class=v6 job line is unnameable (pool/kit-row/pool-{1,2,3}.json carry that refusal in the driver's shape). CUDA: the 5090's phase 1 PASS at 22:00 and 22:24 UK (gen 6 worker 804a6f7f, 47.6 s); phases 2 and 3 running at the time of this record (the fleet lane's runner restarted at 22:22 UK for the three-context file; its stray phase 2 and 3 lines at 22:23 were the restart's artefact, overwritten by the clean sequence). Rule 24 on same-work-node cc23f9bd on build-2: crate check rc 0, igneum-miner suite 30 passed 0 failed.", + "cells": [ + { + "cell": "harness:same-work", + "cases": [ + "R2-F03-R02" + ], + "status": "NOT RUN", + "method": "GPU", + "evidence": "build-1:/srv/artefacts/tas/same-work-20261008-02/node/node-1.json; build-1:/srv/artefacts/tas/same-work-20261008-02/node/node-2.json; build-1:/srv/artefacts/tas/same-work-20261008-02/node/node-3.json; build-1:/srv/artefacts/tas/same-work-20261008-02/node/node.log; build-1:/srv/artefacts/tas/same-work-20261008-02/references/ref-D.txt; build-1:/srv/artefacts/tas/same-work-20261008-02/references/ref-D1.txt; build-1:/srv/artefacts/tas/same-work-20261008-02/job-context.json; build-1:/srv/artefacts/tas/same-work-20261008-02/pool/kit-row/pool-1.json; build-1:/srv/artefacts/tas/same-work-20261008-02/pool/kit-row/pool-2.json; build-1:/srv/artefacts/tas/same-work-20261008-02/pool/kit-row/pool-3.json", + "note": "node PASS x3, CPU reference written and cross-checked, CUDA 5090 phase 1 PASS and phases 2 and 3 running, pool D1 pairing rerun pending after the install fix, pool kit row BLOCKED by its V5 pins, Metal and OpenCL NOT RUN until the morning (Metal 08:30 UK on the mini, OpenCL 08:30 UK on PC 1); the case stays NOT RUN in progress until every reader has read", + "network_label": "on an island, not a network", + "in_progress": true + }, + { + "cell": "harness:same-work", + "cases": [ + "R2-F03-R03" + ], + "status": "NOT RUN", + "method": "GPU", + "evidence": "build-1:/srv/artefacts/tas/same-work-20261008-02/node/node-1.json; build-1:/srv/artefacts/tas/same-work-20261008-02/node/node-2.json; build-1:/srv/artefacts/tas/same-work-20261008-02/node/node-3.json; build-1:/srv/artefacts/tas/same-work-20261008-02/node/node.log; build-1:/srv/artefacts/tas/same-work-20261008-02/references/ref-D.txt; build-1:/srv/artefacts/tas/same-work-20261008-02/references/ref-D1.txt; build-1:/srv/artefacts/tas/same-work-20261008-02/job-context.json", + "note": "the dataset-day transition in phase 2: the node reader switched program and dataset at nonce 1572864 with the program id unchanged and both boundary hashes equal to the reference; the CUDA and pool phase 2 reads are pending; in progress", + "network_label": "on an island, not a network", + "in_progress": true + } + ] +} \ No newline at end of file diff --git a/tools/ci/batches/same-work-20261008-03.json b/tools/ci/batches/same-work-20261008-03.json new file mode 100644 index 000000000..407664c63 --- /dev/null +++ b/tools/ci/batches/same-work-20261008-03.json @@ -0,0 +1,50 @@ +{ + "run_id": "same-work-20261008-03", + "manifest_sha": "c30ab32c", + "method": "GPU", + "evidence_dir": "build-1:/srv/artefacts/tas/same-work-20261008-03", + "boxes": [ + "build-4 (CPU reference)", + "build-2 (program-id witness)", + "tas-p01-5090", + "tas-p01-4090", + "tas-p01-3090" + ], + "release_identity": { + "lockfile": "", + "activation": "none (a re-check of hashes against one job context, no chain state changes)", + "profile_hashes": "", + "commit": "c30ab32c (release-2.0.1; the class v5 freeze 1c420786, fingerprint cbc5bd0a); the CUDA reader the kit's gen 5 worker 9bfcf728", + "binary": "igneum-pow sha256 7ba781db... (release-2.0.1 c30ab32c, built on build-4); igneum-worker-cuda gen 5 sha256 9bfcf728...", + "network_object": "igneum-devnet-4's class v5 object at epoch 2: id 0x81fbfa3aa413173f, epoch seed 3c3fab43... (the epoch-2 seed block, chain block 3423, common to every chain tonight: the split came after it), day 20734, era 0 seed 7c36b833... (class v5 reads no era; the id is the same under era zero), state stream state-epoch2.igsd1 (sha256 f36e6bba..., 21,132 bytes, 224 records, root 0xf798d1d8...) pulled at 22:18 UK from build-1's seed EVM RPC 27810" + }, + "claim_impact": "the same-work test's live-chain half (the coordinator's third row, 22:1x UK): the readers on the chain's own class v5 object at epoch 2 across the day switch 20734 to 20735; the node and pool readers run it on their release-line engines, the row those two can PASS without the class v6 branch", + "network_label": "on an island, not a network", + "note": "On an island, not a network: build-1's seed is one of devnet-4's islands since the epoch-3 cut (21:34 UK), its stream pulled at 22:18 UK; epoch 2's object predates the split. Context 03 at build-1:/srv/artefacts/tas/same-work-20261008-03/job-context.json (sha256 53837a96...). The witness for the id: igneum-miner program-id reads class v5 attempt 0 id 81fbfa3aa413173f under era 7c36b833... and era 00..00 alike, from the miner at same-work-node cc23f9bd on build-2 (the class v5 engine path; the 2.0.1 pair's miner ef0f2ed8 on build-1 has no program-id subcommand), and the node lane's placed (c) read gave the same id; the hand's RPC 26870 answered no published state stream for the block at 22:18 UK. Packs v5-epoch2-d20734 and d20735 (both id 0x81fbfa3aa413173f) exported from release-2.0.1's igneum-pow on build-4 at 22:19 UK; the CPU references run on build-4 under watchers from 22:20 UK (about 300 nonces a second a run); CUDA follows on the pods after contexts 02 and 01. Node and pool: the recheck subcommand is not on a release-line branch tonight, so those cells read NOT RUN with the 08:30 UK clock as the coordinator set; a labelled extra row from cc23f9bd's miner runs beside them when the references land.", + "cells": [ + { + "cell": "harness:same-work", + "cases": [ + "R2-F03-R02" + ], + "status": "NOT RUN", + "method": "GPU", + "evidence": "build-1:/srv/artefacts/tas/same-work-20261008-03/job-context.json; build-1:/srv/artefacts/tas/same-work-20261008-03/state-epoch2.igsd1", + "note": "CPU reference running (about 23:45 UK), CUDA after it, node and pool NOT RUN with the 08:30 UK clock on the release lines; in progress", + "network_label": "on an island, not a network", + "in_progress": true + }, + { + "cell": "harness:same-work", + "cases": [ + "R2-F03-R03" + ], + "status": "NOT RUN", + "method": "GPU", + "evidence": "build-1:/srv/artefacts/tas/same-work-20261008-03/job-context.json", + "note": "the day switch 20734 to 20735 at nonce 1572864 on the live object; readers pending; in progress", + "network_label": "on an island, not a network", + "in_progress": true + } + ] +} \ No newline at end of file