From b5c42dfc2a8eddeffb8d37c669178fa04169f050 Mon Sep 17 00:00:00 2001 From: gensokyo-dev <342580529+gensokyo-dev@users.noreply.github.com> Date: Sat, 24 Oct 2026 13:16:08 +0800 Subject: [PATCH] perf(entropy): separate physical reads from report resolution (#6950) * perf(entropy): separate physical reads from report blocks * test(entropy): type the injected positional short-read boundary * test(entropy): retain full catalog transport capacity in task probe * docs(perf): record real entropy task costs and limits * docs(perf): record latest-main entropy qualification --- .../analysis-efficiency/byte-entropy-costs.py | 94 ++ .../byte-entropy-oracle.py | 56 + .../byte-entropy-reads.json | 1430 +++++++++++++++++ .../analysis-efficiency/byte-entropy-reads.md | 158 ++ .../byte-entropy-reads.mjs | 154 ++ .../ByteEntropyService.test.ts | 64 + .../binaryDiagnostics/ByteEntropyService.ts | 24 +- 7 files changed, 1973 insertions(+), 7 deletions(-) create mode 100644 experiments/analysis-efficiency/byte-entropy-costs.py create mode 100644 experiments/analysis-efficiency/byte-entropy-oracle.py create mode 100644 experiments/analysis-efficiency/byte-entropy-reads.json create mode 100644 experiments/analysis-efficiency/byte-entropy-reads.md create mode 100644 experiments/analysis-efficiency/byte-entropy-reads.mjs diff --git a/experiments/analysis-efficiency/byte-entropy-costs.py b/experiments/analysis-efficiency/byte-entropy-costs.py new file mode 100644 index 0000000000..60050574e7 --- /dev/null +++ b/experiments/analysis-efficiency/byte-entropy-costs.py @@ -0,0 +1,94 @@ +"""Verify 18 completed entropy tasks and report whole-task resource/token costs.""" +import argparse +from pathlib import Path +import hashlib, json, statistics +import tiktoken +parser = argparse.ArgumentParser(description=__doc__) +parser.add_argument('--receipts', type=Path, required=True) +parser.add_argument('--output', type=Path, required=True) +options = parser.parse_args() +b = options.receipts +cohort = b / 'cohort' +index = json.loads((cohort / 'index.json').read_text()) +assert len(index) == 18 and all((r['exit'] == 0 for r in index)) +assert len({item['name'] for item in index}) == 18 +enc = tiktoken.get_encoding('cl100k_base') +compact = lambda d: json.dumps(d, ensure_ascii=False, separators=(',', ':'), allow_nan=False) +count = lambda s: len(enc.encode(s, disallowed_special=())) +digest = lambda p: hashlib.sha256(p.read_bytes()).hexdigest() +rows = [] +for item in index: + p = cohort / item['name'] + r = json.loads((p / 'report.json').read_text()) + catalog = json.loads((p / 'catalog.json').read_text()) + tx = json.loads((p / 'transcript.json').read_text()) + scope = next((json.loads(l) for l in reversed((cohort / (item['name'] + '.log')).read_text().splitlines()) if l.startswith('{"resource_scope":'))) + obs = scope['payload_resource_observation'] + events = obs['resource_events'] + assert r['oracle_sha256'] == digest(b / f"{item['case']}-oracle.json") + assert item['exit'] == 0 and r['status'] == 'passed' and r['complete_source_export_verified'] and (not r['cleanup_failures']) and (not r['receipt_failures']) + assert scope['abort'] is None and scope['payload_resource_observation_verified'] and (obs['payload_exit_code'] == 0) and obs['payload_cleanup_verified'] + assert all((events['memory.events'][k] == 0 for k in ['high', 'max', 'oom', 'oom_kill'])) and events['pids.events']['max'] == 0 + assert [e['name'] for e in tx] == ['inspect_byte_entropy', 'export_evidence_bundle'] + assert all((not e['reply'].get('isError', False) for e in tx)) + inp = count(compact([{k: t[k] for k in ['name', 'description', 'inputSchema']} for t in catalog['tools']])) + args = sum((count(compact({'name': e['name'], 'arguments': e['input']})) for e in tx)) + replies = sum((count(c['text']) for e in tx for c in e['reply']['content'] if c['type'] == 'text')) + prompt = count(r['question']) + instructions = count(r['server_instructions']) + rows.append({ + **item, + 'catalog_tools': len(catalog['tools']), + 'catalog_sha256': digest(p / 'catalog.json'), + 'parent_evidence_id': r['parent_evidence_id'], + 'source_report_sha256': r['source_report_sha256'], + 'runtime_identity_sha256': r['runtime_identity_sha256'], + 'wall_seconds': scope['elapsed_seconds'], + 'cpu_seconds': obs['cpu_stat']['usage_usec'] / 1000000.0, + 'kernel_family_peak_bytes': obs['memory_peak_bytes'], + 'inspection_ms': r['calls'][0]['elapsed_ms'], + 'discovery_ms': r['phases']['discovery_ms'], + 'token_estimate': { + 'question': prompt, + 'instructions': instructions, + 'directory_once': inp, + 'arguments': args, + 'text_replies': replies, + 'whole_task': prompt + instructions + inp + args + replies, + 'raw_catalog': count(compact(catalog)), + }, + 'receipt_sha256': {n: digest(p / n) for n in ['report.json', 'transcript.json', 'catalog.json', 'source.evidence.json']}, + 'payload_exit_events': events, + 'payload_cleanup_verified': True, + 'whole_scope_events_final': scope['resource_events_final'], + }) +summary = {} +for case in ['llvm-small-block', 'llvm-large-block', 'ls']: + rs = [r for r in rows if r['case'] == case] + for k in ['catalog_sha256', 'source_report_sha256', 'parent_evidence_id']: + assert len({r[k] for r in rs}) == 1, (case, k) + summary[case] = {} + for lane in ['before', 'after']: + ls = [r for r in rs if r['lane'] == lane] + assert len(ls) == 3 + assert {r['repeat'] for r in ls} == {1, 2, 3} + metrics = {k: [r[k] for r in ls] for k in ['wall_seconds', 'cpu_seconds', 'kernel_family_peak_bytes', 'inspection_ms', 'discovery_ms']} + metrics['whole_task_tokens'] = [r['token_estimate']['whole_task'] for r in ls] + summary[case][lane] = {k: {'median': statistics.median(v), 'min': min(v), 'max': max(v)} for k, v in metrics.items()} +identities = {lane: json.loads((b / f'{lane}-runtime-identity.json').read_text()) for lane in ['before', 'after']} +assert all(identity['source_clean'] for identity in identities.values()) +for row in rows: + assert row['runtime_identity_sha256'] == digest(b / f"{row['lane']}-runtime-identity.json") +result = { + 'tiktoken': tiktoken.__version__, + 'encoding': enc.name, + 'actual_model_usage': None, + 'revisions': {l: i['source_revision'] for l, i in identities.items()}, + 'identity_receipts': {l: digest(b / f'{l}-runtime-identity.json') for l in identities}, + 'oracles': {c: {'sha256': digest(b / f'{c}-oracle.json'), 'artifact': json.loads((b / f'{c}-oracle.json').read_text())['expected']['artifact']} for c in summary}, + 'summary': summary, + 'recordings': rows, + 'measurement': 'Three alternating fresh production stdio SDK sessions per lane/case; exact discovered toolDefinition/default validator, fresh HOME, Node compile cache disabled, OS caches unflushed. Each task discovers complete catalog, inspects bytes and exports/compares full source Evidence; all oracle facts checked. Whole process-family CPU and kernel peak include client/server, runtime fingerprint verification, serialization, export and cleanup. Oracle generation and tokenization outside measured tasks. One-CPU quota, 3GiB early stop/4GiB hard/no swap; payload exit/cleanup/events verified, final whole-scope counters unavailable. Token serialization estimate includes question/instructions/all input name+description+schema once/all arguments/all text replies, raw catalog separately. Host framing, replay, model inference quality and billing unmeasured.', +} +options.output.write_text(json.dumps(result, indent=2) + '\n') +print(json.dumps(summary, indent=2)) diff --git a/experiments/analysis-efficiency/byte-entropy-oracle.py b/experiments/analysis-efficiency/byte-entropy-oracle.py new file mode 100644 index 0000000000..a3032b478b --- /dev/null +++ b/experiments/analysis-efficiency/byte-entropy-oracle.py @@ -0,0 +1,56 @@ +"""Independent Python histogram oracle; reads artifact bytes without execution.""" +import argparse +from collections import Counter +import hashlib +import json +import math +from pathlib import Path + +def entropy(counts, size): + if not size: + return 0 + value = -sum((counts[k] / size) * math.log2(counts[k] / size) for k in sorted(counts) if counts[k]) + return math.floor(value * 10000 + 0.5) / 10000 + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--path', required=True) + parser.add_argument('--output', required=True) + parser.add_argument('--block-size', type=int, required=True) + parser.add_argument('--offset', type=int, default=0) + parser.add_argument('--length', type=int) + args = parser.parse_args() + path = Path(args.path) + before = path.stat() + counts = Counter() + digest = hashlib.sha256() + with path.open('rb') as source: + while chunk := source.read(1024 * 1024): + digest.update(chunk) + counts.update(chunk) + length = args.length if args.length is not None else before.st_size - args.offset + assert 0 <= args.offset <= before.st_size and 0 <= length <= before.st_size - args.offset + blocks, runs = [], [] + source.seek(args.offset) + for offset in range(args.offset, args.offset + length, args.block_size): + chunk = source.read(min(args.block_size, args.offset + length - offset)) + value = entropy(Counter(chunk), len(chunk)) + block = {'offset': offset, 'length': len(chunk), 'entropy': value} + blocks.append(block) + classification = 'high' if value >= 7.2 else 'low' if value <= 1 else None + if classification is not None: + if runs and runs[-1]['classification'] == classification and runs[-1]['offset'] + runs[-1]['length'] == offset: + runs[-1]['length'] += len(chunk) + else: + runs.append({'offset': offset, 'length': len(chunk), 'classification': classification}) + after = path.stat() + assert (before.st_dev, before.st_ino, before.st_size, before.st_mtime_ns, before.st_ctime_ns) == (after.st_dev, after.st_ino, after.st_size, after.st_mtime_ns, after.st_ctime_ns) + expected = {'artifact': {'path': args.path, 'bytes': before.st_size, 'sha256': digest.hexdigest()}, 'block_size':args.block_size,'window':{'offset':args.offset,'length':length},'file_entropy':entropy(counts,before.st_size),'thresholds':{'high':7.2,'low':1},'blocks':blocks,'runs':runs} + request = {'path':args.path,'block_size':args.block_size,'offset':args.offset} + if args.length is not None: + request['length'] = args.length + Path(args.output).write_text(json.dumps({'input':request,'expected':expected},indent=2)+'\n') + print(json.dumps({'path':args.path,'sha256':digest.hexdigest(),'blocks':len(blocks),'runs':len(runs)})) + +if __name__ == '__main__': + main() diff --git a/experiments/analysis-efficiency/byte-entropy-reads.json b/experiments/analysis-efficiency/byte-entropy-reads.json new file mode 100644 index 0000000000..150429774e --- /dev/null +++ b/experiments/analysis-efficiency/byte-entropy-reads.json @@ -0,0 +1,1430 @@ +{ + "tiktoken": "0.14.0", + "encoding": "cl100k_base", + "actual_model_usage": null, + "revisions": { + "before": "1d896e03b776453282beca7fd89338be778bfca2", + "after": "3ed3276d0ee79c291e1006901ace5b06626c1d4e" + }, + "identity_receipts": { + "before": "7a14d7a9282c44ab720b080a1d2d5fc2c3acb84f1ca8185a95afcb8ccbbd73b9", + "after": "a2d2a57495756565a50d7d3098066bf4210991ac79d5c3ab96f81cc8a40d128a" + }, + "oracles": { + "llvm-small-block": { + "sha256": "8c3edeb30472bb1092ed250412b33ffeaacbba58da474c010c76390628241aad", + "artifact": { + "path": "/usr/lib/x86_64-linux-gnu/libLLVM-16.so.1", + "bytes": 123379936, + "sha256": "f62d254b7f2bf42df8c8b07d46ee3bb4c2cafeca436b2e6bc6ccbe4581f58f40" + } + }, + "llvm-large-block": { + "sha256": "9aab6dba368a251f3f54feefd9147de148c0f6cdc60e6344cf765c7a4844cb80", + "artifact": { + "path": "/usr/lib/x86_64-linux-gnu/libLLVM-16.so.1", + "bytes": 123379936, + "sha256": "f62d254b7f2bf42df8c8b07d46ee3bb4c2cafeca436b2e6bc6ccbe4581f58f40" + } + }, + "ls": { + "sha256": "ff4e6b59cb10b98f6687120b77224e2e33a9615bfaa307eadec3b6a3da8a73f5", + "artifact": { + "path": "/usr/bin/ls", + "bytes": 151344, + "sha256": "cb30d69b24245bf2ecdc9e7f53bbad19159999970b6d82c0c00c7d32d9e37aa4" + } + } + }, + "summary": { + "llvm-small-block": { + "before": { + "wall_seconds": { + "median": 29.842, + "min": 28.541, + "max": 33.29 + }, + "cpu_seconds": { + "median": 25.286236, + "min": 23.600276, + "max": 25.428612 + }, + "kernel_family_peak_bytes": { + "median": 660090880, + "min": 650514432, + "max": 668438528 + }, + "inspection_ms": { + "median": 24862.077908, + "min": 24796.278229, + "max": 29515.395641 + }, + "discovery_ms": { + "median": 1062.3440920000003, + "min": 1056.1659610000002, + "max": 1339.2179160000003 + }, + "whole_task_tokens": { + "median": 62000, + "min": 62000, + "max": 62000 + } + }, + "after": { + "wall_seconds": { + "median": 8.584, + "min": 7.981, + "max": 10.396 + }, + "cpu_seconds": { + "median": 6.358016, + "min": 6.048826, + "max": 6.63289 + }, + "kernel_family_peak_bytes": { + "median": 705114112, + "min": 698036224, + "max": 705949696 + }, + "inspection_ms": { + "median": 4213.348502999999, + "min": 3920.4952740000003, + "max": 5781.0953389999995 + }, + "discovery_ms": { + "median": 1112.952316, + "min": 1106.7913999999998, + "max": 1396.260179 + }, + "whole_task_tokens": { + "median": 62000, + "min": 62000, + "max": 62000 + } + } + }, + "llvm-large-block": { + "before": { + "wall_seconds": { + "median": 12.314, + "min": 9.095, + "max": 17.957 + }, + "cpu_seconds": { + "median": 7.580575, + "min": 6.934466, + "max": 8.476001 + }, + "kernel_family_peak_bytes": { + "median": 700346368, + "min": 663851008, + "max": 705323008 + }, + "inspection_ms": { + "median": 7798.0581010000005, + "min": 5327.810836000001, + "max": 7879.026692 + }, + "discovery_ms": { + "median": 1442.5241819999999, + "min": 1119.990668, + "max": 2455.198091 + }, + "whole_task_tokens": { + "median": 91900, + "min": 91900, + "max": 91900 + } + }, + "after": { + "wall_seconds": { + "median": 12.115, + "min": 8.285, + "max": 13.319 + }, + "cpu_seconds": { + "median": 7.325135, + "min": 7.049975, + "max": 7.446041 + }, + "kernel_family_peak_bytes": { + "median": 707096576, + "min": 702083072, + "max": 708579328 + }, + "inspection_ms": { + "median": 6899.755944, + "min": 4762.259958000001, + "max": 7711.982530000001 + }, + "discovery_ms": { + "median": 1430.1016910000003, + "min": 1088.6852219999998, + "max": 1525.502455 + }, + "whole_task_tokens": { + "median": 91900, + "min": 91900, + "max": 91900 + } + } + }, + "ls": { + "before": { + "wall_seconds": { + "median": 7.075, + "min": 6.469, + "max": 9.892 + }, + "cpu_seconds": { + "median": 5.804089, + "min": 5.564724, + "max": 5.868173 + }, + "kernel_family_peak_bytes": { + "median": 691068928, + "min": 664076288, + "max": 691322880 + }, + "inspection_ms": { + "median": 2788.714276, + "min": 2753.4078409999997, + "max": 4401.935402 + }, + "discovery_ms": { + "median": 1071.0256309999997, + "min": 988.3230369999999, + "max": 1323.905776 + }, + "whole_task_tokens": { + "median": 67215, + "min": 67215, + "max": 67215 + } + }, + "after": { + "wall_seconds": { + "median": 8.286, + "min": 6.169, + "max": 9.188 + }, + "cpu_seconds": { + "median": 5.528156, + "min": 5.401958, + "max": 5.749299 + }, + "kernel_family_peak_bytes": { + "median": 691326976, + "min": 684163072, + "max": 693678080 + }, + "inspection_ms": { + "median": 3604.7330589999997, + "min": 2798.7924759999996, + "max": 3954.776057 + }, + "discovery_ms": { + "median": 1103.981563, + "min": 987.2837319999999, + "max": 1400.601354 + }, + "whole_task_tokens": { + "median": 67215, + "min": 67215, + "max": 67215 + } + } + } + }, + "recordings": [ + { + "name": "llvm-small-block-1-before", + "case": "llvm-small-block", + "lane": "before", + "repeat": 1, + "command": [ + "python3", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/resource-run.py", + "--observe-payload-exit", + "--", + "/tmp/rea-perf-native-exports-20261023/run-task.sh", + "env", + "NODE_DISABLE_COMPILE_CACHE=1", + "node", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/byte-entropy-reads.mjs", + "--runtime", + "/home/yann/yann/rea-perf-static-tool-audit-20261024", + "--oracle", + "/tmp/rea-perf-byte-entropy-20261024/llvm-small-block-oracle.json", + "--identity", + "/tmp/rea-perf-byte-entropy-20261024/before-runtime-identity.json", + "--output", + "/tmp/rea-perf-byte-entropy-20261024/cohort/llvm-small-block-1-before" + ], + "exit": 0, + "catalog_tools": 222, + "catalog_sha256": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "parent_evidence_id": "ev_4a27946fd5072db2f8ec817b55b0cb24e11213542828a895ab719d77a5cc6d05", + "source_report_sha256": "00fed6fa92201271f7f2187b13d16686c782482fca922c772ec353fb2e321868", + "runtime_identity_sha256": "7a14d7a9282c44ab720b080a1d2d5fc2c3acb84f1ca8185a95afcb8ccbbd73b9", + "wall_seconds": 29.842, + "cpu_seconds": 25.428612, + "kernel_family_peak_bytes": 660090880, + "inspection_ms": 24796.278229, + "discovery_ms": 1056.1659610000002, + "token_estimate": { + "question": 32, + "instructions": 513, + "directory_once": 56685, + "arguments": 80, + "text_replies": 4690, + "whole_task": 62000, + "raw_catalog": 838375 + }, + "receipt_sha256": { + "report.json": "c8ac36fec41db539fcdc73fa06210cf1aa275b5c523239b3529ef04455ca61e7", + "transcript.json": "cd7a625762d76dee5c2e6dcf02c2f13bb007ed5eba2bfcd72954992107b0e74b", + "catalog.json": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "source.evidence.json": "e250e777492bb82153cb3d57ece0d8fb8ec9d2eb238f0d648761592fd4441ff7" + }, + "payload_exit_events": { + "memory.events": { + "low": 0, + "high": 0, + "max": 0, + "oom": 0, + "oom_kill": 0, + "oom_group_kill": 0 + }, + "pids.events": { + "max": 0 + } + }, + "payload_cleanup_verified": true, + "whole_scope_events_final": null + }, + { + "name": "llvm-small-block-1-after", + "case": "llvm-small-block", + "lane": "after", + "repeat": 1, + "command": [ + "python3", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/resource-run.py", + "--observe-payload-exit", + "--", + "/tmp/rea-perf-native-exports-20261023/run-task.sh", + "env", + "NODE_DISABLE_COMPILE_CACHE=1", + "node", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/byte-entropy-reads.mjs", + "--runtime", + "/home/yann/yann/rea-perf-entropy-reads-20261024", + "--oracle", + "/tmp/rea-perf-byte-entropy-20261024/llvm-small-block-oracle.json", + "--identity", + "/tmp/rea-perf-byte-entropy-20261024/after-runtime-identity.json", + "--output", + "/tmp/rea-perf-byte-entropy-20261024/cohort/llvm-small-block-1-after" + ], + "exit": 0, + "catalog_tools": 222, + "catalog_sha256": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "parent_evidence_id": "ev_4a27946fd5072db2f8ec817b55b0cb24e11213542828a895ab719d77a5cc6d05", + "source_report_sha256": "00fed6fa92201271f7f2187b13d16686c782482fca922c772ec353fb2e321868", + "runtime_identity_sha256": "a2d2a57495756565a50d7d3098066bf4210991ac79d5c3ab96f81cc8a40d128a", + "wall_seconds": 8.584, + "cpu_seconds": 6.63289, + "kernel_family_peak_bytes": 705949696, + "inspection_ms": 3920.4952740000003, + "discovery_ms": 1112.952316, + "token_estimate": { + "question": 32, + "instructions": 513, + "directory_once": 56685, + "arguments": 80, + "text_replies": 4690, + "whole_task": 62000, + "raw_catalog": 838375 + }, + "receipt_sha256": { + "report.json": "d266fbb30bc2f79ed4fa9e4ea6e801a8aafe67f96d2855bb90d105c32314cb13", + "transcript.json": "54b367813185f8ff84885e330f26e601ae6c7177da8fcaf4bb2061046d1af368", + "catalog.json": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "source.evidence.json": "e250e777492bb82153cb3d57ece0d8fb8ec9d2eb238f0d648761592fd4441ff7" + }, + "payload_exit_events": { + "memory.events": { + "low": 0, + "high": 0, + "max": 0, + "oom": 0, + "oom_kill": 0, + "oom_group_kill": 0 + }, + "pids.events": { + "max": 0 + } + }, + "payload_cleanup_verified": true, + "whole_scope_events_final": null + }, + { + "name": "llvm-small-block-2-after", + "case": "llvm-small-block", + "lane": "after", + "repeat": 2, + "command": [ + "python3", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/resource-run.py", + "--observe-payload-exit", + "--", + "/tmp/rea-perf-native-exports-20261023/run-task.sh", + "env", + "NODE_DISABLE_COMPILE_CACHE=1", + "node", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/byte-entropy-reads.mjs", + "--runtime", + "/home/yann/yann/rea-perf-entropy-reads-20261024", + "--oracle", + "/tmp/rea-perf-byte-entropy-20261024/llvm-small-block-oracle.json", + "--identity", + "/tmp/rea-perf-byte-entropy-20261024/after-runtime-identity.json", + "--output", + "/tmp/rea-perf-byte-entropy-20261024/cohort/llvm-small-block-2-after" + ], + "exit": 0, + "catalog_tools": 222, + "catalog_sha256": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "parent_evidence_id": "ev_4a27946fd5072db2f8ec817b55b0cb24e11213542828a895ab719d77a5cc6d05", + "source_report_sha256": "00fed6fa92201271f7f2187b13d16686c782482fca922c772ec353fb2e321868", + "runtime_identity_sha256": "a2d2a57495756565a50d7d3098066bf4210991ac79d5c3ab96f81cc8a40d128a", + "wall_seconds": 7.981, + "cpu_seconds": 6.358016, + "kernel_family_peak_bytes": 705114112, + "inspection_ms": 4213.348502999999, + "discovery_ms": 1106.7913999999998, + "token_estimate": { + "question": 32, + "instructions": 513, + "directory_once": 56685, + "arguments": 80, + "text_replies": 4690, + "whole_task": 62000, + "raw_catalog": 838375 + }, + "receipt_sha256": { + "report.json": "7acbf49fbb7c72fcccfce9dfe8762e4e28b51d2bdd39bb47bf64cbdb50dbe59b", + "transcript.json": "4559f30a6d47c5535e339033493b2b57f107b7c04c92ce494afce9fc81e6dbc1", + "catalog.json": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "source.evidence.json": "e250e777492bb82153cb3d57ece0d8fb8ec9d2eb238f0d648761592fd4441ff7" + }, + "payload_exit_events": { + "memory.events": { + "low": 0, + "high": 0, + "max": 0, + "oom": 0, + "oom_kill": 0, + "oom_group_kill": 0 + }, + "pids.events": { + "max": 0 + } + }, + "payload_cleanup_verified": true, + "whole_scope_events_final": null + }, + { + "name": "llvm-small-block-2-before", + "case": "llvm-small-block", + "lane": "before", + "repeat": 2, + "command": [ + "python3", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/resource-run.py", + "--observe-payload-exit", + "--", + "/tmp/rea-perf-native-exports-20261023/run-task.sh", + "env", + "NODE_DISABLE_COMPILE_CACHE=1", + "node", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/byte-entropy-reads.mjs", + "--runtime", + "/home/yann/yann/rea-perf-static-tool-audit-20261024", + "--oracle", + "/tmp/rea-perf-byte-entropy-20261024/llvm-small-block-oracle.json", + "--identity", + "/tmp/rea-perf-byte-entropy-20261024/before-runtime-identity.json", + "--output", + "/tmp/rea-perf-byte-entropy-20261024/cohort/llvm-small-block-2-before" + ], + "exit": 0, + "catalog_tools": 222, + "catalog_sha256": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "parent_evidence_id": "ev_4a27946fd5072db2f8ec817b55b0cb24e11213542828a895ab719d77a5cc6d05", + "source_report_sha256": "00fed6fa92201271f7f2187b13d16686c782482fca922c772ec353fb2e321868", + "runtime_identity_sha256": "7a14d7a9282c44ab720b080a1d2d5fc2c3acb84f1ca8185a95afcb8ccbbd73b9", + "wall_seconds": 28.541, + "cpu_seconds": 23.600276, + "kernel_family_peak_bytes": 668438528, + "inspection_ms": 24862.077908, + "discovery_ms": 1339.2179160000003, + "token_estimate": { + "question": 32, + "instructions": 513, + "directory_once": 56685, + "arguments": 80, + "text_replies": 4690, + "whole_task": 62000, + "raw_catalog": 838375 + }, + "receipt_sha256": { + "report.json": "ca2e55932d806e289210015e570abd70a6e00c5831e57e6839f2da4724c9302c", + "transcript.json": "aa32660dc0970c41dad7b4ddd0f8051253e5a95fbb2f332a34b379823e12e5dd", + "catalog.json": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "source.evidence.json": "e250e777492bb82153cb3d57ece0d8fb8ec9d2eb238f0d648761592fd4441ff7" + }, + "payload_exit_events": { + "memory.events": { + "low": 0, + "high": 0, + "max": 0, + "oom": 0, + "oom_kill": 0, + "oom_group_kill": 0 + }, + "pids.events": { + "max": 0 + } + }, + "payload_cleanup_verified": true, + "whole_scope_events_final": null + }, + { + "name": "llvm-small-block-3-before", + "case": "llvm-small-block", + "lane": "before", + "repeat": 3, + "command": [ + "python3", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/resource-run.py", + "--observe-payload-exit", + "--", + "/tmp/rea-perf-native-exports-20261023/run-task.sh", + "env", + "NODE_DISABLE_COMPILE_CACHE=1", + "node", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/byte-entropy-reads.mjs", + "--runtime", + "/home/yann/yann/rea-perf-static-tool-audit-20261024", + "--oracle", + "/tmp/rea-perf-byte-entropy-20261024/llvm-small-block-oracle.json", + "--identity", + "/tmp/rea-perf-byte-entropy-20261024/before-runtime-identity.json", + "--output", + "/tmp/rea-perf-byte-entropy-20261024/cohort/llvm-small-block-3-before" + ], + "exit": 0, + "catalog_tools": 222, + "catalog_sha256": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "parent_evidence_id": "ev_4a27946fd5072db2f8ec817b55b0cb24e11213542828a895ab719d77a5cc6d05", + "source_report_sha256": "00fed6fa92201271f7f2187b13d16686c782482fca922c772ec353fb2e321868", + "runtime_identity_sha256": "7a14d7a9282c44ab720b080a1d2d5fc2c3acb84f1ca8185a95afcb8ccbbd73b9", + "wall_seconds": 33.29, + "cpu_seconds": 25.286236, + "kernel_family_peak_bytes": 650514432, + "inspection_ms": 29515.395641, + "discovery_ms": 1062.3440920000003, + "token_estimate": { + "question": 32, + "instructions": 513, + "directory_once": 56685, + "arguments": 80, + "text_replies": 4690, + "whole_task": 62000, + "raw_catalog": 838375 + }, + "receipt_sha256": { + "report.json": "26acb427b1b4e264ad092501028d2543eecaae79a8c37dd00f7ac30111ddf40f", + "transcript.json": "896af044ad686d2e7fcd3f1b4352ae8e3044de2604baee2031c006ebae5db1f7", + "catalog.json": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "source.evidence.json": "e250e777492bb82153cb3d57ece0d8fb8ec9d2eb238f0d648761592fd4441ff7" + }, + "payload_exit_events": { + "memory.events": { + "low": 0, + "high": 0, + "max": 0, + "oom": 0, + "oom_kill": 0, + "oom_group_kill": 0 + }, + "pids.events": { + "max": 0 + } + }, + "payload_cleanup_verified": true, + "whole_scope_events_final": null + }, + { + "name": "llvm-small-block-3-after", + "case": "llvm-small-block", + "lane": "after", + "repeat": 3, + "command": [ + "python3", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/resource-run.py", + "--observe-payload-exit", + "--", + "/tmp/rea-perf-native-exports-20261023/run-task.sh", + "env", + "NODE_DISABLE_COMPILE_CACHE=1", + "node", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/byte-entropy-reads.mjs", + "--runtime", + "/home/yann/yann/rea-perf-entropy-reads-20261024", + "--oracle", + "/tmp/rea-perf-byte-entropy-20261024/llvm-small-block-oracle.json", + "--identity", + "/tmp/rea-perf-byte-entropy-20261024/after-runtime-identity.json", + "--output", + "/tmp/rea-perf-byte-entropy-20261024/cohort/llvm-small-block-3-after" + ], + "exit": 0, + "catalog_tools": 222, + "catalog_sha256": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "parent_evidence_id": "ev_4a27946fd5072db2f8ec817b55b0cb24e11213542828a895ab719d77a5cc6d05", + "source_report_sha256": "00fed6fa92201271f7f2187b13d16686c782482fca922c772ec353fb2e321868", + "runtime_identity_sha256": "a2d2a57495756565a50d7d3098066bf4210991ac79d5c3ab96f81cc8a40d128a", + "wall_seconds": 10.396, + "cpu_seconds": 6.048826, + "kernel_family_peak_bytes": 698036224, + "inspection_ms": 5781.0953389999995, + "discovery_ms": 1396.260179, + "token_estimate": { + "question": 32, + "instructions": 513, + "directory_once": 56685, + "arguments": 80, + "text_replies": 4690, + "whole_task": 62000, + "raw_catalog": 838375 + }, + "receipt_sha256": { + "report.json": "2fd342b60e88b5e0265221f5a69df4adf545107fe69df4f52f2bdb0a59b63cd0", + "transcript.json": "b6e2e0eb119b483ca690cadf4b638d33d0aefd49cf382c4aaad1d766d7b37f95", + "catalog.json": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "source.evidence.json": "e250e777492bb82153cb3d57ece0d8fb8ec9d2eb238f0d648761592fd4441ff7" + }, + "payload_exit_events": { + "memory.events": { + "low": 0, + "high": 0, + "max": 0, + "oom": 0, + "oom_kill": 0, + "oom_group_kill": 0 + }, + "pids.events": { + "max": 0 + } + }, + "payload_cleanup_verified": true, + "whole_scope_events_final": null + }, + { + "name": "llvm-large-block-1-before", + "case": "llvm-large-block", + "lane": "before", + "repeat": 1, + "command": [ + "python3", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/resource-run.py", + "--observe-payload-exit", + "--", + "/tmp/rea-perf-native-exports-20261023/run-task.sh", + "env", + "NODE_DISABLE_COMPILE_CACHE=1", + "node", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/byte-entropy-reads.mjs", + "--runtime", + "/home/yann/yann/rea-perf-static-tool-audit-20261024", + "--oracle", + "/tmp/rea-perf-byte-entropy-20261024/llvm-large-block-oracle.json", + "--identity", + "/tmp/rea-perf-byte-entropy-20261024/before-runtime-identity.json", + "--output", + "/tmp/rea-perf-byte-entropy-20261024/cohort/llvm-large-block-1-before" + ], + "exit": 0, + "catalog_tools": 222, + "catalog_sha256": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "parent_evidence_id": "ev_95c2526af2a7e197f1bd05b94e254da37631fb93d41c0738dd6e7ada141994a7", + "source_report_sha256": "4caca811267410bbc81ad5eba5f5cb7fb80b1bb064729d91adf6fbb2b8b7a611", + "runtime_identity_sha256": "7a14d7a9282c44ab720b080a1d2d5fc2c3acb84f1ca8185a95afcb8ccbbd73b9", + "wall_seconds": 17.957, + "cpu_seconds": 8.476001, + "kernel_family_peak_bytes": 663851008, + "inspection_ms": 7879.026692, + "discovery_ms": 2455.198091, + "token_estimate": { + "question": 32, + "instructions": 513, + "directory_once": 56685, + "arguments": 76, + "text_replies": 34594, + "whole_task": 91900, + "raw_catalog": 838375 + }, + "receipt_sha256": { + "report.json": "ad2f1a74a64518b5a88536f0aca629e4dee83c9f053a53000fdaecc425eee48f", + "transcript.json": "2afc5c5daabaaabed6bed2d1f12b125d858196257d20b84059341bee2aa920c3", + "catalog.json": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "source.evidence.json": "d45a4a687adce34a893dc0978c7596bb713fd018d477524a99e086b47d11ca9d" + }, + "payload_exit_events": { + "memory.events": { + "low": 0, + "high": 0, + "max": 0, + "oom": 0, + "oom_kill": 0, + "oom_group_kill": 0 + }, + "pids.events": { + "max": 0 + } + }, + "payload_cleanup_verified": true, + "whole_scope_events_final": null + }, + { + "name": "llvm-large-block-1-after", + "case": "llvm-large-block", + "lane": "after", + "repeat": 1, + "command": [ + "python3", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/resource-run.py", + "--observe-payload-exit", + "--", + "/tmp/rea-perf-native-exports-20261023/run-task.sh", + "env", + "NODE_DISABLE_COMPILE_CACHE=1", + "node", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/byte-entropy-reads.mjs", + "--runtime", + "/home/yann/yann/rea-perf-entropy-reads-20261024", + "--oracle", + "/tmp/rea-perf-byte-entropy-20261024/llvm-large-block-oracle.json", + "--identity", + "/tmp/rea-perf-byte-entropy-20261024/after-runtime-identity.json", + "--output", + "/tmp/rea-perf-byte-entropy-20261024/cohort/llvm-large-block-1-after" + ], + "exit": 0, + "catalog_tools": 222, + "catalog_sha256": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "parent_evidence_id": "ev_95c2526af2a7e197f1bd05b94e254da37631fb93d41c0738dd6e7ada141994a7", + "source_report_sha256": "4caca811267410bbc81ad5eba5f5cb7fb80b1bb064729d91adf6fbb2b8b7a611", + "runtime_identity_sha256": "a2d2a57495756565a50d7d3098066bf4210991ac79d5c3ab96f81cc8a40d128a", + "wall_seconds": 12.115, + "cpu_seconds": 7.049975, + "kernel_family_peak_bytes": 707096576, + "inspection_ms": 6899.755944, + "discovery_ms": 1525.502455, + "token_estimate": { + "question": 32, + "instructions": 513, + "directory_once": 56685, + "arguments": 76, + "text_replies": 34594, + "whole_task": 91900, + "raw_catalog": 838375 + }, + "receipt_sha256": { + "report.json": "643c97711d54f9c63fa77637e2ccae186a5ea245962126cdba5113d9091b6ff3", + "transcript.json": "fb0dd5d99181c0f3ed242b96ffa93410226ebad5bddb4db20441c69f1f3e2e80", + "catalog.json": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "source.evidence.json": "d45a4a687adce34a893dc0978c7596bb713fd018d477524a99e086b47d11ca9d" + }, + "payload_exit_events": { + "memory.events": { + "low": 0, + "high": 0, + "max": 0, + "oom": 0, + "oom_kill": 0, + "oom_group_kill": 0 + }, + "pids.events": { + "max": 0 + } + }, + "payload_cleanup_verified": true, + "whole_scope_events_final": null + }, + { + "name": "llvm-large-block-2-after", + "case": "llvm-large-block", + "lane": "after", + "repeat": 2, + "command": [ + "python3", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/resource-run.py", + "--observe-payload-exit", + "--", + "/tmp/rea-perf-native-exports-20261023/run-task.sh", + "env", + "NODE_DISABLE_COMPILE_CACHE=1", + "node", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/byte-entropy-reads.mjs", + "--runtime", + "/home/yann/yann/rea-perf-entropy-reads-20261024", + "--oracle", + "/tmp/rea-perf-byte-entropy-20261024/llvm-large-block-oracle.json", + "--identity", + "/tmp/rea-perf-byte-entropy-20261024/after-runtime-identity.json", + "--output", + "/tmp/rea-perf-byte-entropy-20261024/cohort/llvm-large-block-2-after" + ], + "exit": 0, + "catalog_tools": 222, + "catalog_sha256": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "parent_evidence_id": "ev_95c2526af2a7e197f1bd05b94e254da37631fb93d41c0738dd6e7ada141994a7", + "source_report_sha256": "4caca811267410bbc81ad5eba5f5cb7fb80b1bb064729d91adf6fbb2b8b7a611", + "runtime_identity_sha256": "a2d2a57495756565a50d7d3098066bf4210991ac79d5c3ab96f81cc8a40d128a", + "wall_seconds": 13.319, + "cpu_seconds": 7.325135, + "kernel_family_peak_bytes": 702083072, + "inspection_ms": 7711.982530000001, + "discovery_ms": 1430.1016910000003, + "token_estimate": { + "question": 32, + "instructions": 513, + "directory_once": 56685, + "arguments": 76, + "text_replies": 34594, + "whole_task": 91900, + "raw_catalog": 838375 + }, + "receipt_sha256": { + "report.json": "e1beda23320577291a8bbb75246ea142e0846219e6b70486fc9820d025e9e0b6", + "transcript.json": "e351f27922938c10cec3c7ccf1f3acf07a3f0accecf9f317f7be7f4bfd964d38", + "catalog.json": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "source.evidence.json": "d45a4a687adce34a893dc0978c7596bb713fd018d477524a99e086b47d11ca9d" + }, + "payload_exit_events": { + "memory.events": { + "low": 0, + "high": 0, + "max": 0, + "oom": 0, + "oom_kill": 0, + "oom_group_kill": 0 + }, + "pids.events": { + "max": 0 + } + }, + "payload_cleanup_verified": true, + "whole_scope_events_final": null + }, + { + "name": "llvm-large-block-2-before", + "case": "llvm-large-block", + "lane": "before", + "repeat": 2, + "command": [ + "python3", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/resource-run.py", + "--observe-payload-exit", + "--", + "/tmp/rea-perf-native-exports-20261023/run-task.sh", + "env", + "NODE_DISABLE_COMPILE_CACHE=1", + "node", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/byte-entropy-reads.mjs", + "--runtime", + "/home/yann/yann/rea-perf-static-tool-audit-20261024", + "--oracle", + "/tmp/rea-perf-byte-entropy-20261024/llvm-large-block-oracle.json", + "--identity", + "/tmp/rea-perf-byte-entropy-20261024/before-runtime-identity.json", + "--output", + "/tmp/rea-perf-byte-entropy-20261024/cohort/llvm-large-block-2-before" + ], + "exit": 0, + "catalog_tools": 222, + "catalog_sha256": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "parent_evidence_id": "ev_95c2526af2a7e197f1bd05b94e254da37631fb93d41c0738dd6e7ada141994a7", + "source_report_sha256": "4caca811267410bbc81ad5eba5f5cb7fb80b1bb064729d91adf6fbb2b8b7a611", + "runtime_identity_sha256": "7a14d7a9282c44ab720b080a1d2d5fc2c3acb84f1ca8185a95afcb8ccbbd73b9", + "wall_seconds": 12.314, + "cpu_seconds": 6.934466, + "kernel_family_peak_bytes": 700346368, + "inspection_ms": 7798.0581010000005, + "discovery_ms": 1442.5241819999999, + "token_estimate": { + "question": 32, + "instructions": 513, + "directory_once": 56685, + "arguments": 76, + "text_replies": 34594, + "whole_task": 91900, + "raw_catalog": 838375 + }, + "receipt_sha256": { + "report.json": "15b9da16f1f471440debf3a37a3de3c6b3f323936bda30291337cce238502d54", + "transcript.json": "a2b958397689f03e5ef3a0c9dc634c5e9d444bc865993a8756a883692c320a69", + "catalog.json": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "source.evidence.json": "d45a4a687adce34a893dc0978c7596bb713fd018d477524a99e086b47d11ca9d" + }, + "payload_exit_events": { + "memory.events": { + "low": 0, + "high": 0, + "max": 0, + "oom": 0, + "oom_kill": 0, + "oom_group_kill": 0 + }, + "pids.events": { + "max": 0 + } + }, + "payload_cleanup_verified": true, + "whole_scope_events_final": null + }, + { + "name": "llvm-large-block-3-before", + "case": "llvm-large-block", + "lane": "before", + "repeat": 3, + "command": [ + "python3", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/resource-run.py", + "--observe-payload-exit", + "--", + "/tmp/rea-perf-native-exports-20261023/run-task.sh", + "env", + "NODE_DISABLE_COMPILE_CACHE=1", + "node", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/byte-entropy-reads.mjs", + "--runtime", + "/home/yann/yann/rea-perf-static-tool-audit-20261024", + "--oracle", + "/tmp/rea-perf-byte-entropy-20261024/llvm-large-block-oracle.json", + "--identity", + "/tmp/rea-perf-byte-entropy-20261024/before-runtime-identity.json", + "--output", + "/tmp/rea-perf-byte-entropy-20261024/cohort/llvm-large-block-3-before" + ], + "exit": 0, + "catalog_tools": 222, + "catalog_sha256": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "parent_evidence_id": "ev_95c2526af2a7e197f1bd05b94e254da37631fb93d41c0738dd6e7ada141994a7", + "source_report_sha256": "4caca811267410bbc81ad5eba5f5cb7fb80b1bb064729d91adf6fbb2b8b7a611", + "runtime_identity_sha256": "7a14d7a9282c44ab720b080a1d2d5fc2c3acb84f1ca8185a95afcb8ccbbd73b9", + "wall_seconds": 9.095, + "cpu_seconds": 7.580575, + "kernel_family_peak_bytes": 705323008, + "inspection_ms": 5327.810836000001, + "discovery_ms": 1119.990668, + "token_estimate": { + "question": 32, + "instructions": 513, + "directory_once": 56685, + "arguments": 76, + "text_replies": 34594, + "whole_task": 91900, + "raw_catalog": 838375 + }, + "receipt_sha256": { + "report.json": "6d322a8fb97b69fe21b784b82a48965cfae4dfc68a4d7b8488da11e0b0ad3275", + "transcript.json": "2487fd135bb1e703b240dd46b73dec42a09daedc54ac9537df1d5c6aca83569b", + "catalog.json": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "source.evidence.json": "d45a4a687adce34a893dc0978c7596bb713fd018d477524a99e086b47d11ca9d" + }, + "payload_exit_events": { + "memory.events": { + "low": 0, + "high": 0, + "max": 0, + "oom": 0, + "oom_kill": 0, + "oom_group_kill": 0 + }, + "pids.events": { + "max": 0 + } + }, + "payload_cleanup_verified": true, + "whole_scope_events_final": null + }, + { + "name": "llvm-large-block-3-after", + "case": "llvm-large-block", + "lane": "after", + "repeat": 3, + "command": [ + "python3", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/resource-run.py", + "--observe-payload-exit", + "--", + "/tmp/rea-perf-native-exports-20261023/run-task.sh", + "env", + "NODE_DISABLE_COMPILE_CACHE=1", + "node", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/byte-entropy-reads.mjs", + "--runtime", + "/home/yann/yann/rea-perf-entropy-reads-20261024", + "--oracle", + "/tmp/rea-perf-byte-entropy-20261024/llvm-large-block-oracle.json", + "--identity", + "/tmp/rea-perf-byte-entropy-20261024/after-runtime-identity.json", + "--output", + "/tmp/rea-perf-byte-entropy-20261024/cohort/llvm-large-block-3-after" + ], + "exit": 0, + "catalog_tools": 222, + "catalog_sha256": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "parent_evidence_id": "ev_95c2526af2a7e197f1bd05b94e254da37631fb93d41c0738dd6e7ada141994a7", + "source_report_sha256": "4caca811267410bbc81ad5eba5f5cb7fb80b1bb064729d91adf6fbb2b8b7a611", + "runtime_identity_sha256": "a2d2a57495756565a50d7d3098066bf4210991ac79d5c3ab96f81cc8a40d128a", + "wall_seconds": 8.285, + "cpu_seconds": 7.446041, + "kernel_family_peak_bytes": 708579328, + "inspection_ms": 4762.259958000001, + "discovery_ms": 1088.6852219999998, + "token_estimate": { + "question": 32, + "instructions": 513, + "directory_once": 56685, + "arguments": 76, + "text_replies": 34594, + "whole_task": 91900, + "raw_catalog": 838375 + }, + "receipt_sha256": { + "report.json": "1dacfb55d2a0b2ea1568fb657163b449e7d6ae1acdc0940a2a41e4a42f6c4b72", + "transcript.json": "ba4d1c9d7480765b515b75534a582a4dfbcaf0c4832b5cec9d6a2c6ff25f0ceb", + "catalog.json": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "source.evidence.json": "d45a4a687adce34a893dc0978c7596bb713fd018d477524a99e086b47d11ca9d" + }, + "payload_exit_events": { + "memory.events": { + "low": 0, + "high": 0, + "max": 0, + "oom": 0, + "oom_kill": 0, + "oom_group_kill": 0 + }, + "pids.events": { + "max": 0 + } + }, + "payload_cleanup_verified": true, + "whole_scope_events_final": null + }, + { + "name": "ls-1-before", + "case": "ls", + "lane": "before", + "repeat": 1, + "command": [ + "python3", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/resource-run.py", + "--observe-payload-exit", + "--", + "/tmp/rea-perf-native-exports-20261023/run-task.sh", + "env", + "NODE_DISABLE_COMPILE_CACHE=1", + "node", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/byte-entropy-reads.mjs", + "--runtime", + "/home/yann/yann/rea-perf-static-tool-audit-20261024", + "--oracle", + "/tmp/rea-perf-byte-entropy-20261024/ls-oracle.json", + "--identity", + "/tmp/rea-perf-byte-entropy-20261024/before-runtime-identity.json", + "--output", + "/tmp/rea-perf-byte-entropy-20261024/cohort/ls-1-before" + ], + "exit": 0, + "catalog_tools": 222, + "catalog_sha256": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "parent_evidence_id": "ev_a69f96696a9f0c7f4ef7d28eacac454a3177b54ffc3f0171f48481c95e54bb00", + "source_report_sha256": "bdecdc567e749c52d6d4f31c59032946c59719d0c817b4ad555ba79896bb0e83", + "runtime_identity_sha256": "7a14d7a9282c44ab720b080a1d2d5fc2c3acb84f1ca8185a95afcb8ccbbd73b9", + "wall_seconds": 6.469, + "cpu_seconds": 5.804089, + "kernel_family_peak_bytes": 691068928, + "inspection_ms": 2753.4078409999997, + "discovery_ms": 988.3230369999999, + "token_estimate": { + "question": 32, + "instructions": 513, + "directory_once": 56685, + "arguments": 61, + "text_replies": 9924, + "whole_task": 67215, + "raw_catalog": 838375 + }, + "receipt_sha256": { + "report.json": "8fa0a65917d28c9a1be93fe6fc5d2649f97a29c1401c798c465607f30bcc2510", + "transcript.json": "72c7694e07465c7f434b8d1f7853d4c010917f5a50f9f82baf1321791d8931d9", + "catalog.json": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "source.evidence.json": "8e5a9243caaca7bea1fd709c781fe313f4334bc103dd0dbc06660195f8dde420" + }, + "payload_exit_events": { + "memory.events": { + "low": 0, + "high": 0, + "max": 0, + "oom": 0, + "oom_kill": 0, + "oom_group_kill": 0 + }, + "pids.events": { + "max": 0 + } + }, + "payload_cleanup_verified": true, + "whole_scope_events_final": null + }, + { + "name": "ls-1-after", + "case": "ls", + "lane": "after", + "repeat": 1, + "command": [ + "python3", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/resource-run.py", + "--observe-payload-exit", + "--", + "/tmp/rea-perf-native-exports-20261023/run-task.sh", + "env", + "NODE_DISABLE_COMPILE_CACHE=1", + "node", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/byte-entropy-reads.mjs", + "--runtime", + "/home/yann/yann/rea-perf-entropy-reads-20261024", + "--oracle", + "/tmp/rea-perf-byte-entropy-20261024/ls-oracle.json", + "--identity", + "/tmp/rea-perf-byte-entropy-20261024/after-runtime-identity.json", + "--output", + "/tmp/rea-perf-byte-entropy-20261024/cohort/ls-1-after" + ], + "exit": 0, + "catalog_tools": 222, + "catalog_sha256": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "parent_evidence_id": "ev_a69f96696a9f0c7f4ef7d28eacac454a3177b54ffc3f0171f48481c95e54bb00", + "source_report_sha256": "bdecdc567e749c52d6d4f31c59032946c59719d0c817b4ad555ba79896bb0e83", + "runtime_identity_sha256": "a2d2a57495756565a50d7d3098066bf4210991ac79d5c3ab96f81cc8a40d128a", + "wall_seconds": 8.286, + "cpu_seconds": 5.749299, + "kernel_family_peak_bytes": 684163072, + "inspection_ms": 3604.7330589999997, + "discovery_ms": 1103.981563, + "token_estimate": { + "question": 32, + "instructions": 513, + "directory_once": 56685, + "arguments": 61, + "text_replies": 9924, + "whole_task": 67215, + "raw_catalog": 838375 + }, + "receipt_sha256": { + "report.json": "238427864393640abec8333755af1e6fb824518e3afc3b1a9af89a469778bfd6", + "transcript.json": "882e34a885df0ead76f137290d6846054882b99ef2be738837a6c3a784410344", + "catalog.json": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "source.evidence.json": "8e5a9243caaca7bea1fd709c781fe313f4334bc103dd0dbc06660195f8dde420" + }, + "payload_exit_events": { + "memory.events": { + "low": 0, + "high": 0, + "max": 0, + "oom": 0, + "oom_kill": 0, + "oom_group_kill": 0 + }, + "pids.events": { + "max": 0 + } + }, + "payload_cleanup_verified": true, + "whole_scope_events_final": null + }, + { + "name": "ls-2-after", + "case": "ls", + "lane": "after", + "repeat": 2, + "command": [ + "python3", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/resource-run.py", + "--observe-payload-exit", + "--", + "/tmp/rea-perf-native-exports-20261023/run-task.sh", + "env", + "NODE_DISABLE_COMPILE_CACHE=1", + "node", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/byte-entropy-reads.mjs", + "--runtime", + "/home/yann/yann/rea-perf-entropy-reads-20261024", + "--oracle", + "/tmp/rea-perf-byte-entropy-20261024/ls-oracle.json", + "--identity", + "/tmp/rea-perf-byte-entropy-20261024/after-runtime-identity.json", + "--output", + "/tmp/rea-perf-byte-entropy-20261024/cohort/ls-2-after" + ], + "exit": 0, + "catalog_tools": 222, + "catalog_sha256": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "parent_evidence_id": "ev_a69f96696a9f0c7f4ef7d28eacac454a3177b54ffc3f0171f48481c95e54bb00", + "source_report_sha256": "bdecdc567e749c52d6d4f31c59032946c59719d0c817b4ad555ba79896bb0e83", + "runtime_identity_sha256": "a2d2a57495756565a50d7d3098066bf4210991ac79d5c3ab96f81cc8a40d128a", + "wall_seconds": 9.188, + "cpu_seconds": 5.401958, + "kernel_family_peak_bytes": 691326976, + "inspection_ms": 3954.776057, + "discovery_ms": 1400.601354, + "token_estimate": { + "question": 32, + "instructions": 513, + "directory_once": 56685, + "arguments": 61, + "text_replies": 9924, + "whole_task": 67215, + "raw_catalog": 838375 + }, + "receipt_sha256": { + "report.json": "b369e16e21a54f6f6a312c2b8f294eb2110c324614b4bb3ac187650fe8870e3f", + "transcript.json": "fd50a0a729e26186c50d45944207533d3b97ade2e81ec2f4ce6d250e9a7e7906", + "catalog.json": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "source.evidence.json": "8e5a9243caaca7bea1fd709c781fe313f4334bc103dd0dbc06660195f8dde420" + }, + "payload_exit_events": { + "memory.events": { + "low": 0, + "high": 0, + "max": 0, + "oom": 0, + "oom_kill": 0, + "oom_group_kill": 0 + }, + "pids.events": { + "max": 0 + } + }, + "payload_cleanup_verified": true, + "whole_scope_events_final": null + }, + { + "name": "ls-2-before", + "case": "ls", + "lane": "before", + "repeat": 2, + "command": [ + "python3", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/resource-run.py", + "--observe-payload-exit", + "--", + "/tmp/rea-perf-native-exports-20261023/run-task.sh", + "env", + "NODE_DISABLE_COMPILE_CACHE=1", + "node", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/byte-entropy-reads.mjs", + "--runtime", + "/home/yann/yann/rea-perf-static-tool-audit-20261024", + "--oracle", + "/tmp/rea-perf-byte-entropy-20261024/ls-oracle.json", + "--identity", + "/tmp/rea-perf-byte-entropy-20261024/before-runtime-identity.json", + "--output", + "/tmp/rea-perf-byte-entropy-20261024/cohort/ls-2-before" + ], + "exit": 0, + "catalog_tools": 222, + "catalog_sha256": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "parent_evidence_id": "ev_a69f96696a9f0c7f4ef7d28eacac454a3177b54ffc3f0171f48481c95e54bb00", + "source_report_sha256": "bdecdc567e749c52d6d4f31c59032946c59719d0c817b4ad555ba79896bb0e83", + "runtime_identity_sha256": "7a14d7a9282c44ab720b080a1d2d5fc2c3acb84f1ca8185a95afcb8ccbbd73b9", + "wall_seconds": 9.892, + "cpu_seconds": 5.564724, + "kernel_family_peak_bytes": 664076288, + "inspection_ms": 4401.935402, + "discovery_ms": 1323.905776, + "token_estimate": { + "question": 32, + "instructions": 513, + "directory_once": 56685, + "arguments": 61, + "text_replies": 9924, + "whole_task": 67215, + "raw_catalog": 838375 + }, + "receipt_sha256": { + "report.json": "c4b3eb936d5b386cb3a1487d1635ad773472242b315eac9aee5bd1dc3d4e6662", + "transcript.json": "b6262b8224d6e32e38ac706952a79161b84bde11c97d49114090b804c2be8fd7", + "catalog.json": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "source.evidence.json": "8e5a9243caaca7bea1fd709c781fe313f4334bc103dd0dbc06660195f8dde420" + }, + "payload_exit_events": { + "memory.events": { + "low": 0, + "high": 0, + "max": 0, + "oom": 0, + "oom_kill": 0, + "oom_group_kill": 0 + }, + "pids.events": { + "max": 0 + } + }, + "payload_cleanup_verified": true, + "whole_scope_events_final": null + }, + { + "name": "ls-3-before", + "case": "ls", + "lane": "before", + "repeat": 3, + "command": [ + "python3", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/resource-run.py", + "--observe-payload-exit", + "--", + "/tmp/rea-perf-native-exports-20261023/run-task.sh", + "env", + "NODE_DISABLE_COMPILE_CACHE=1", + "node", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/byte-entropy-reads.mjs", + "--runtime", + "/home/yann/yann/rea-perf-static-tool-audit-20261024", + "--oracle", + "/tmp/rea-perf-byte-entropy-20261024/ls-oracle.json", + "--identity", + "/tmp/rea-perf-byte-entropy-20261024/before-runtime-identity.json", + "--output", + "/tmp/rea-perf-byte-entropy-20261024/cohort/ls-3-before" + ], + "exit": 0, + "catalog_tools": 222, + "catalog_sha256": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "parent_evidence_id": "ev_a69f96696a9f0c7f4ef7d28eacac454a3177b54ffc3f0171f48481c95e54bb00", + "source_report_sha256": "bdecdc567e749c52d6d4f31c59032946c59719d0c817b4ad555ba79896bb0e83", + "runtime_identity_sha256": "7a14d7a9282c44ab720b080a1d2d5fc2c3acb84f1ca8185a95afcb8ccbbd73b9", + "wall_seconds": 7.075, + "cpu_seconds": 5.868173, + "kernel_family_peak_bytes": 691322880, + "inspection_ms": 2788.714276, + "discovery_ms": 1071.0256309999997, + "token_estimate": { + "question": 32, + "instructions": 513, + "directory_once": 56685, + "arguments": 61, + "text_replies": 9924, + "whole_task": 67215, + "raw_catalog": 838375 + }, + "receipt_sha256": { + "report.json": "f52001fe53650d3062a1e440c5c5f91e43ba12382835651fb8b6a4ad1b5943cf", + "transcript.json": "7afb6207f443a736d8ab11368947614b2f40bb8e22594dbcd02c4e88039b557b", + "catalog.json": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "source.evidence.json": "8e5a9243caaca7bea1fd709c781fe313f4334bc103dd0dbc06660195f8dde420" + }, + "payload_exit_events": { + "memory.events": { + "low": 0, + "high": 0, + "max": 0, + "oom": 0, + "oom_kill": 0, + "oom_group_kill": 0 + }, + "pids.events": { + "max": 0 + } + }, + "payload_cleanup_verified": true, + "whole_scope_events_final": null + }, + { + "name": "ls-3-after", + "case": "ls", + "lane": "after", + "repeat": 3, + "command": [ + "python3", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/resource-run.py", + "--observe-payload-exit", + "--", + "/tmp/rea-perf-native-exports-20261023/run-task.sh", + "env", + "NODE_DISABLE_COMPILE_CACHE=1", + "node", + "/home/yann/yann/rea-perf-entropy-reads-20261024/experiments/analysis-efficiency/byte-entropy-reads.mjs", + "--runtime", + "/home/yann/yann/rea-perf-entropy-reads-20261024", + "--oracle", + "/tmp/rea-perf-byte-entropy-20261024/ls-oracle.json", + "--identity", + "/tmp/rea-perf-byte-entropy-20261024/after-runtime-identity.json", + "--output", + "/tmp/rea-perf-byte-entropy-20261024/cohort/ls-3-after" + ], + "exit": 0, + "catalog_tools": 222, + "catalog_sha256": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "parent_evidence_id": "ev_a69f96696a9f0c7f4ef7d28eacac454a3177b54ffc3f0171f48481c95e54bb00", + "source_report_sha256": "bdecdc567e749c52d6d4f31c59032946c59719d0c817b4ad555ba79896bb0e83", + "runtime_identity_sha256": "a2d2a57495756565a50d7d3098066bf4210991ac79d5c3ab96f81cc8a40d128a", + "wall_seconds": 6.169, + "cpu_seconds": 5.528156, + "kernel_family_peak_bytes": 693678080, + "inspection_ms": 2798.7924759999996, + "discovery_ms": 987.2837319999999, + "token_estimate": { + "question": 32, + "instructions": 513, + "directory_once": 56685, + "arguments": 61, + "text_replies": 9924, + "whole_task": 67215, + "raw_catalog": 838375 + }, + "receipt_sha256": { + "report.json": "54474d0bc47458aead95f872ea3c94a651f2419280ab35857d2393c7ffcdbb18", + "transcript.json": "04a63c8e7e9b916c1dae3299d9f1952aef8e7f4cf1e227109a6ab6b3a5f4c458", + "catalog.json": "4b2ac38e76ee3cbbdd6763230e1e5abbbbb0c760c8476efb5e036957d5021644", + "source.evidence.json": "8e5a9243caaca7bea1fd709c781fe313f4334bc103dd0dbc06660195f8dde420" + }, + "payload_exit_events": { + "memory.events": { + "low": 0, + "high": 0, + "max": 0, + "oom": 0, + "oom_kill": 0, + "oom_group_kill": 0 + }, + "pids.events": { + "max": 0 + } + }, + "payload_cleanup_verified": true, + "whole_scope_events_final": null + } + ], + "measurement": "Three alternating fresh production stdio SDK sessions per lane/case; exact discovered toolDefinition/default validator, fresh HOME, Node compile cache disabled, OS caches unflushed. Each task discovers complete catalog, inspects bytes and exports/compares full source Evidence; all oracle facts checked. Whole process-family CPU and kernel peak include client/server, runtime fingerprint verification, serialization, export and cleanup. Oracle generation and tokenization outside measured tasks. One-CPU quota, 3GiB early stop/4GiB hard/no swap; payload exit/cleanup/events verified, final whole-scope counters unavailable. Token serialization estimate includes question/instructions/all input name+description+schema once/all arguments/all text replies, raw catalog separately. Host framing, replay, model inference quality and billing unmeasured." +} diff --git a/experiments/analysis-efficiency/byte-entropy-reads.md b/experiments/analysis-efficiency/byte-entropy-reads.md new file mode 100644 index 0000000000..8c28981d4a --- /dev/null +++ b/experiments/analysis-efficiency/byte-entropy-reads.md @@ -0,0 +1,158 @@ +# Byte entropy: separate physical reads from report resolution + +Issue: [#6947](https://github.com/morluto/rea/issues/6947). + +The question is to return the full-file SHA-256 and entropy, every block in a +selected byte window, and adjacent high/low runs, preserving complete source +Evidence. `ByteEntropyService` previously used `block_size` for both reporting +and physical reads, including outside the selected window. Small report blocks +therefore caused hundreds of thousands of asynchronous reads of a large file. + +The shared service now fills a bounded 64 KiB buffer before calculating the +caller-selected blocks. Supported power-of-two block sizes divide that buffer; +the window starts its own block sequence, and only its final block can be short. +Short physical reads are joined before interpretation. The same stable-file, +whole-file hash, cancellation, capacity and descriptor-cleanup owners remain. +No new cache, parser, contract or output selection is introduced. + +## Fixed comparison + +Baseline: `1d896e03b776453282beca7fd89338be778bfca2`. +Measured implementation: `3ed3276d0ee79c291e1006901ace5b06626c1d4e`. +Both were clean and built with Node 24.22.1, npm 11.16.0 and SDK 2.3.1. +The runtime receipt fingerprints 2,582 compiled/catalog/entrypoint/dependency +and driver files in each lane, checked before and after every task. + +Real artifacts are installed Linux x64 binaries, inspected without execution: + +| Artifact | Bytes | SHA-256 | +| ----------------------------------------------------- | ----------: | ------------------------------------------------------------------ | +| LLVM 16 (`/usr/lib/x86_64-linux-gnu/libLLVM-16.so.1`) | 123,379,936 | `f62d254b7f2bf42df8c8b07d46ee3bb4c2cafeca436b2e6bc6ccbe4581f58f40` | +| GNU ls (`/usr/bin/ls`) | 151,344 | `cb30d69b24245bf2ecdc9e7f53bbad19159999970b6d82c0c00c7d32d9e37aa4` | + +`byte-entropy-oracle.py` independently computes Python byte histograms, +Shannon entropy, selected blocks, rounded-value run classifications and digests. +It checks file state around its reads. Every returned fact agrees with this +oracle, and both lanes have identical complete report hashes and Evidence IDs. + +There are three alternating fresh production stdio MCP sessions per lane/case, +18 tasks total. Each discovers all 222 tools, uses exact discovered +`toolDefinition` validation, inspects the bytes, exports the complete Evidence +bundle and verifies its parent record. Fresh HOME/client/server, Node compile +cache disabled, OS caches unflushed. These are fresh sessions; no warm-runtime +speedup is claimed. Cached-catalog SDK bulk validation was not measured here. + +| Task (3 samples per lane) | Whole elapsed median, s | Family CPU median, s | Kernel family peak median, MiB | Whole-task estimated tokens | +| ----------------------------------------------------------- | ----------------------: | -------------------: | -----------------------------: | --------------------------: | +| LLVM: 256-byte blocks, offset 3, length 65,539 (257 blocks) | 29.842 → 8.584 | 25.286 → 6.358 | 629.5 → 672.4 | 62,000 → 62,000 | +| LLVM: whole file, 65,536-byte blocks (1,883 blocks) | 12.314 → 12.115 | 7.581 → 7.325 | 667.9 → 674.3 | 91,900 → 91,900 | +| ls: whole file, 256-byte blocks (592 blocks) | 7.075 → 8.286 | 5.804 → 5.528 | 659.1 → 659.3 | 67,215 → 67,215 | + +The large fine-resolution task improves elapsed median by 71.2% and CPU by +74.9%. Elapsed ranges are 28.541–33.290 → 7.981–10.396 seconds; CPU ranges +23.600–25.429 → 6.049–6.633 seconds. Its kernel peak increases by about +43 MiB (ranges 620.4–637.5 → 665.7–673.2 MiB). This is a speed/CPU improvement +with higher measured peak memory, not a memory optimization. + +The other controls do not establish a stable whole-task speedup. The small +file's elapsed median is worse; ranges overlap at 6.469–9.892 → 6.169–9.188 +seconds. No general latency or memory benefit is claimed. Full-file reading +and hashing remain necessary even when the selected window is short or empty. + +A separate single real-file service probe delegated to actual `open/stat/read` +while counting reads: 481,955 → 1,885 physical reads of all 123,379,936 bytes, +maximum request 256 → 65,536 bytes, service elapsed 17.09 → 1.34 seconds. +The complete Evidence objects were equal and independently checked. This probe +locates the work removed; it is not the repeated public-task performance table. + +The [machine-readable report](./byte-entropy-reads.json) preserves ranges, +per-sample phase timings, calls, receipt hashes, artifact identities and commands. +`cl100k_base` via tiktoken 0.14.0 counts the fixed question, server instructions, +all tool names/descriptions/input schemas once, every argument and every text +reply including export. Input-directory cost is 56,685 tokens; raw catalog with +output schemas is separately 838,375. Actual model billing, host framing/replay, +model reasoning quality and inference latency were not measured. No token saving +is claimed: replies and catalog remain unchanged. + +## Resource and correctness verification + +All tasks ran serially under a one-CPU quota, 3 GiB early memory stop, 4 GiB hard +limit, zero swap and 192-task ceiling. Whole process-family CPU and kernel memory +peak include client/server, runtime fingerprint reads, serialization, source +export and cleanup; kernel peak includes charged file cache. Independent oracle +generation and tokenization are outside timed tasks. Payload exits, remaining +owned processes and memory/PID-limit events were checked: all task payloads +exited 0, cleanup verified, no guard stop/OOM. Final whole-scope counters were +unavailable after transient-scope removal and are not represented as verified. + +Executed additional checks: + +- Six real CLI calls (three cases in both lanes): every oracle fact, complete + CLI Evidence equality and matching MCP parent identity passed. +- 36 tests in four exact source/public-boundary files passed, including short + reads, unaligned windows across buffers, partial tails at minimum/intermediate/ + maximum block sizes, empty windows, cancellation through finalization, + identity changes, capacity refusal, retained summaries and cleanup retry. +- Six serial static tasks (typecheck, lint including module boundaries, format, + knip, metadata and required compilation), plus architecture guards passed. + Static family peak was 1.96 GiB; focused-test/preparation peak was 2.15 GiB. +- An initial typecheck failure in the new short-read test's injected callback + was fixed with an explicitly typed positional boundary. Its failed receipt is + retained, not counted as a successful run. Initial local formatter path and + early profile verification attempts also failed before their intended checks; + corrected checks are recorded separately. + +The public experiments qualify static byte inspection on these Linux files. +They do not establish behavior on every filesystem or operating system and do +not execute LLVM or ls. CLI/MCP contracts, Evidence fields, input limits and +provider authority remain unchanged; generated catalogs and builds are ignored. + +After integrating main `21a20306b`, the six serial static tasks, architecture +guards and all 36 focused cases passed again. Three fresh real MCP/source-export +tasks and three CLI calls matched every oracle fact and the frozen cohort's +report/parent identity. The integrated test/preparation family peaked at +2.23 GiB with verified payload exit/cleanup and no guard stop/OOM. These are +integration qualification runs; they do not replace the fixed performance pins. +The committed cost verifier also reproduced the complete measurement JSON. + +## Reproduction + +Build both pinned checkouts using their locked toolchain, serially. Supply an +independent installed dependency tree matching the lock, without upgrading host +software. Use the exact artifact digests above. The oracle accepts explicit +`--path`, `--block-size`, `--offset`, `--length` and `--output`; omit length for +the two whole-file controls. For example: + +```sh +python3 experiments/analysis-efficiency/byte-entropy-oracle.py \ + --path /usr/lib/x86_64-linux-gnu/libLLVM-16.so.1 \ + --block-size 256 --offset 3 --length 65539 --output /absolute/oracle.json +python3 experiments/analysis-efficiency/resource-run.py --observe-payload-exit -- \ + node experiments/analysis-efficiency/byte-entropy-reads.mjs \ + --runtime /absolute/pinned-checkout --oracle /absolute/oracle.json \ + --identity /absolute/runtime-identity.json --output /absolute/new-task-directory +``` + +Runtime identity JSON contains `source_revision`, `source_clean`, +`node_sha256` and `files: [{path, sha256}]` with absolute paths. Fingerprint the +entire compiled runtime and catalogs, scripts, lock/toolchain files, actual SDK +JavaScript dependencies and the driver/helpers. Both sessions must use the same +Node and dependency contents. Use the same one-CPU/memory policy for the harness; +the historical runs additionally pinned the payload to CPUs 0–1 and the initial +observer to CPU 15. Do not compare an unguarded default-concurrency run as an +equivalent resource measurement. + +Retained raw receipts are on the investigation host at +`/tmp/rea-perf-byte-entropy-20261024/`. This includes `cohort/index.json`, +per-task catalog/transcript/report/source export/guard logs, runtime identities, +three oracle JSONs, CLI stdout/stderr, boundary profiles and verification logs. +The cost verifier takes that receipt directory and a separate output: + +```sh +python3 experiments/analysis-efficiency/byte-entropy-costs.py \ + --receipts /absolute/receipt-directory --output /absolute/costs.json +``` + +It requires all 18 successful verified samples, matching parent/report/catalog +identity across lanes, successful source exports and oracle/runtime receipts. +Failed or stopped attempts cannot enter the published cohort. diff --git a/experiments/analysis-efficiency/byte-entropy-reads.mjs b/experiments/analysis-efficiency/byte-entropy-reads.mjs new file mode 100644 index 0000000000..f6eaa8529e --- /dev/null +++ b/experiments/analysis-efficiency/byte-entropy-reads.mjs @@ -0,0 +1,154 @@ +/** Complete entropy question through production stdio, with full source export. */ +import assert from "node:assert/strict"; +import { createHash } from "node:crypto"; +import { createWriteStream } from "node:fs"; +import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { join, resolve } from "node:path"; +import { finished } from "node:stream/promises"; +import { parseArgs } from "node:util"; +import { Client } from "@modelcontextprotocol/client"; +import { StdioClientTransport } from "@modelcontextprotocol/client/stdio"; +import { createRetainedQueryCaller } from "./retained-query-calls.mjs"; +import { finalizeRetainedQueryReceipt } from "./retained-query-finalization.mjs"; + +const { values } = parseArgs({ + options: Object.fromEntries( + ["runtime", "oracle", "identity", "output"].map((name) => [ + name, + { type: "string" }, + ]), + ), +}); +for (const value of Object.values(values)) assert.equal(value, resolve(value)); +const sha256 = (value) => createHash("sha256").update(value).digest("hex"); +const oracleBytes = await readFile(values.oracle); +const oracle = JSON.parse(oracleBytes); +const identityBytes = await readFile(values.identity); +const identity = JSON.parse(identityBytes); +await mkdir(values.output, { mode: 0o700 }); +const account = await mkdtemp(join(tmpdir(), "rea-entropy-task-")); +const client = new Client({ name: "entropy-complete-task", version: "1" }); +const transport = new StdioClientTransport({ + command: process.execPath, + args: [join(values.runtime, "scripts/rea.mjs"), "mcp"], + maxBufferSize: 10485760, + env: { + HOME: account, + TMPDIR: account, + PATH: process.env.PATH, + REA_LOG_LEVEL: "silent", + NODE_OPTIONS: "--max-old-space-size=2048", + NODE_DISABLE_COMPILE_CACHE: "1", + UV_THREADPOOL_SIZE: "2", + }, + stderr: "pipe", +}); +const serverLog = createWriteStream(join(values.output, "server.log")); +const serverLogFinished = finished(serverLog); +serverLogFinished.catch(() => {}); +transport.stderr?.pipe(serverLog); +const report = { + status: "running", + question: + "Return the file SHA-256, file-wide entropy, every entropy block and adjacent high/low run in the requested byte window; preserve the complete source Evidence.", + request: oracle.input, + calls: [], + phases: {}, + client: + "Production stdio SDK, exact discovered toolDefinition and default validator", + runtime_identity_sha256: sha256(identityBytes), + oracle_sha256: sha256(oracleBytes), + driver_sha256: sha256(await readFile(new URL(import.meta.url))), +}; +const transcript = []; +let definitions; +const call = createRetainedQueryCaller( + { + callTool(params, options) { + return client.callTool(params, { + ...options, + toolDefinition: definitions.get(params.name), + }); + }, + }, + (receipt, event) => { + report.calls.push(receipt); + transcript.push(event); + }, +); +const observe = async (name, args, phase) => { + const result = await call(name, args, phase); + assert.notEqual(result.isError, true, JSON.stringify(result)); + assert.ok(result.structuredContent); + return result.structuredContent; +}; +const verifyRuntime = async () => { + assert.equal(sha256(await readFile(values.oracle)), sha256(oracleBytes)); + assert.equal(sha256(await readFile(values.identity)), sha256(identityBytes)); + assert.equal(sha256(await readFile(process.execPath)), identity.node_sha256); + assert.equal( + sha256(await readFile(new URL(import.meta.url))), + report.driver_sha256, + ); + for (const item of identity.files) + assert.equal(sha256(await readFile(item.path)), item.sha256, item.path); +}; +try { + await verifyRuntime(); + const start = performance.now(); + await client.connect(transport); + report.server_instructions = client.getInstructions() ?? ""; + const catalog = await client.listTools(); + definitions = new Map(catalog.tools.map((tool) => [tool.name, tool])); + await writeFile(join(values.output, "catalog.json"), JSON.stringify(catalog)); + report.phases.discovery_ms = performance.now() - start; + const parent = await observe("inspect_byte_entropy", oracle.input, "inspect"); + for (const [key, value] of Object.entries(oracle.expected)) + assert.deepEqual(parent.normalized_result[key], value, key); + report.parent_evidence_id = parent.evidence_id; + report.source_report_sha256 = sha256( + JSON.stringify(parent.normalized_result), + ); + report.artifact = parent.normalized_result.artifact; + await observe( + "export_evidence_bundle", + { path: join(values.output, "source.evidence.json") }, + "export", + ); + const bundle = JSON.parse( + await readFile(join(values.output, "source.evidence.json")), + ); + assert.deepEqual( + bundle.records.find((item) => item.evidence_id === parent.evidence_id), + parent, + ); + report.complete_source_export_verified = true; + report.status = "passed"; +} catch (cause) { + report.status = "failed"; + report.error = String(cause); +} finally { + try { + await verifyRuntime(); + } catch (cause) { + report.status = "failed"; + report.identity_failure = String(cause); + } + await finalizeRetainedQueryReceipt({ + client, + transport, + account, + serverLog, + serverLogFinished, + report, + transcript, + output: values.output, + }); + if ( + report.status !== "passed" || + report.cleanup_failures.length || + report.receipt_failures.length + ) + process.exitCode = 1; +} diff --git a/src/application/binaryDiagnostics/ByteEntropyService.test.ts b/src/application/binaryDiagnostics/ByteEntropyService.test.ts index 15300d51ab..c0f2a5fd45 100644 --- a/src/application/binaryDiagnostics/ByteEntropyService.test.ts +++ b/src/application/binaryDiagnostics/ByteEntropyService.test.ts @@ -38,6 +38,70 @@ it("keeps whole-file identity and entropy while selecting unaligned blocks and a expect(result.value.confidence).toBe("observed"); }); +it.each([256, 4096, 65536])( + "keeps %i-byte blocks relative to an unaligned window across short physical reads", + async (blockSize) => { + const root = await createTestTempDirectory("rea-entropy-short-reads-"); + const path = join(root, "bytes"); + const bytes = Buffer.from( + Array.from({ length: 3 * 65536 + 256 }, (_, i) => i % 256), + ); + await writeFile(path, bytes); + let reads = 0; + const service = new ByteEntropyService({ + stat, + open: async (...args) => { + const file = await open(...args); + const read = file.read.bind(file); + Object.defineProperty(file, "read", { + value: async ( + buffer: Buffer, + offset: number, + length: number, + position: number, + ) => { + reads += 1; + return read(buffer, offset, Math.min(length, 3571), position); + }, + }); + return file; + }, + }); + try { + const result = await service.inspect({ + path, + offset: 3, + length: 2 * 65536 + 1, + block_size: blockSize, + }); + if (!result.ok) throw result.error; + const report = byteEntropySchema.parse(result.value.normalized_result); + const fullBlocks = (2 * 65536) / blockSize; + expect(report.blocks).toEqual([ + ...Array.from({ length: fullBlocks }, (_, i) => ({ + offset: 3 + i * blockSize, + length: blockSize, + entropy: 8, + })), + { offset: 3 + 2 * 65536, length: 1, entropy: 0 }, + ]); + expect(report.runs).toEqual([ + { offset: 3, length: 2 * 65536, classification: "high" }, + { offset: 3 + 2 * 65536, length: 1, classification: "low" }, + ]); + expect(report.file_entropy).toBe(8); + expect(report.artifact.sha256).toBe( + createHash("sha256").update(bytes).digest("hex"), + ); + // Even with 3,571-byte short reads, finer report resolution does not + // require hundreds of asynchronous reads of this 193 KiB file. + expect(reads).toBeLessThan(100); + } finally { + await service.close(); + } + }, +); + it("rejects missing files, non-files and windows beyond EOF, but accepts empty windows", async () => { const root = await createTestTempDirectory("rea-entropy-input-"); const path = join(root, "empty"); diff --git a/src/application/binaryDiagnostics/ByteEntropyService.ts b/src/application/binaryDiagnostics/ByteEntropyService.ts index 08dd3c853e..b565feb4b9 100644 --- a/src/application/binaryDiagnostics/ByteEntropyService.ts +++ b/src/application/binaryDiagnostics/ByteEntropyService.ts @@ -241,7 +241,10 @@ export class ByteEntropyService { ); const end = input.offset + length; const blocks: ByteEntropy["blocks"] = []; - const buffer = Buffer.alloc(input.block_size); + // Physical reads must not shrink with report resolution, including + // outside the selected window. Every admitted power-of-two block + // size divides this buffer, so only the window's final block is short. + const buffer = Buffer.alloc(65_536); const counts = new Float64Array(256); const hash = createHash("sha256"); let position = 0; @@ -250,7 +253,7 @@ export class ByteEntropyService { const selected = position >= input.offset && position < end; const boundary = position < input.offset ? input.offset : selected ? end : size; - const wanted = Math.min(input.block_size, boundary - position); + const wanted = Math.min(buffer.length, boundary - position); let filled = 0; while (filled < wanted) { assertArtifactReadActive(options?.signal); @@ -267,11 +270,18 @@ export class ByteEntropyService { hash.update(bytes); for (const byte of bytes) counts[byte] = (counts[byte] ?? 0) + 1; if (selected) - blocks.push({ - offset: position, - length: filled, - entropy: computeBlockEntropy(bytes), - }); + for ( + let offset = 0; + offset < filled; + offset += input.block_size + ) { + const block = bytes.subarray(offset, offset + input.block_size); + blocks.push({ + offset: position + offset, + length: block.length, + entropy: computeBlockEntropy(block), + }); + } position += filled; } if (