diff --git a/research/h25-g12-original-contract-scope/CLAIMS.json b/research/h25-g12-original-contract-scope/CLAIMS.json new file mode 100644 index 0000000000..8cd104fb0f --- /dev/null +++ b/research/h25-g12-original-contract-scope/CLAIMS.json @@ -0,0 +1,34 @@ +{ + "schema": "h25-g12-original-contract-scope-v1", + "resolved": [ + { + "id": "G12-CAUGHT-PRIMARY", + "input": "research/h25-cache-source-handoff/snapshot/review/cache-s0308-source-completion-v2/g12-protocol-independent/G12-CANDIDATE-PROTOCOL-REVIEW-v1.json", + "pointer": "/blocking_findings/0/required_narrow_change", + "source_text": "Protect all newly added secondary bookkeeping that runs while preserving an already-caught P, particularly the last handler at476-477, so failures there cannot escape in place of P. Retain designated secondary errors in pre-existing raw slots before optional allocating journals where required; keep optional reporting guarded. No broader allocation-equivalence proof or new authority framework is required.", + "interpretation": "This bounded repair protects an already-caught primary against newly added bookkeeping. No new universal allocation-equivalence obligation is inferred." + }, + { + "id": "G12-SOURCE-BOUNDARY", + "input": "research/h25-cache-source-handoff/snapshot/review/cache-s0308-source-completion-v2/g12-protocol-independent/G12-CANDIDATE-PROTOCOL-REVIEW-v2.json", + "pointer": "/finding_disposition/0/boundary", + "source_text": "This is static preservation of an already-caught primary against the newly added bookkeeping path. It is not a universal allocation-equivalence proof, actual injected-failure run, or complete original cleanup qualification.", + "interpretation": "The accepted narrow static repair is distinct from injected runtime failure and complete cleanup qualification." + }, + { + "id": "G12-NO-NEW-FINANCIAL-API", + "input": "research/h25-cache-source-handoff/snapshot/review/cache-s0308-source-completion-v2/g12-custody-independent/G12-CUSTODY-SOURCE-SCOPE-CLARIFICATION-v1.json", + "pointer": "/answer", + "source_text": "The inspected original SC5/SC6 checklist and cost/caller contracts do not require construction of a new enclosing financial/accounting API for reference custody. They require authentic independent original reference transport, source and alias ownership, and a complete source work/cost bill preserving actual measurement, limits, all tails and unmeasured quantities. No exact original causal dependency on new F4/M source work was demonstrated. The additional final-publication/enclosing-completion API is a requirement introduced by the G12 design as written; its absence is not by itself a justified original S03.08 source-completion blocker.", + "interpretation": "A newly constructed enclosing accounting API is not an original prerequisite. Authentic transport, ownership, complete work/cost bills, measurements and unknown tails remain required." + } + ], + "conditional_PR6347_witnesses_withdrawn": false, + "new_runtime_or_activity_acceptance": false, + "original_weighted_activity_percent": 43.5, + "original_complete_activities": 22, + "original_activity_denominator": 49, + "stage_gate_percent": 20, + "overall_milestone_percent": 10, + "costs": "OPEN_NOT_ZERO" +} diff --git a/research/h25-g12-original-contract-scope/README.md b/research/h25-g12-original-contract-scope/README.md new file mode 100644 index 0000000000..3ed46a46ca --- /dev/null +++ b/research/h25-g12-original-contract-scope/README.md @@ -0,0 +1,30 @@ +# Original G12 contract scope + +The retained original protocol reviews require preservation of an **already-caught primary** against newly added bookkeeping failures. They explicitly do not demand a broader allocation-equivalence proof or new authority framework for that bounded source repair. The retained custody clarification likewise does not make a newly constructed enclosing financial/accounting API an original S03.08 prerequisite. + +This resolves two scope questions. It does not repair or accept the remaining integration. Authentic independent reference transport, first-primary/raw-secondary identities, closed aliases, cleanup, source/mode/output custody, terminal order, a complete work/cost bill and unknown tails remain original obligations. Neither the original checklist nor a design-specific predicate is silently deleted. Any change to a design that added an enclosing completion API needs its own explicit successor and review. + +## Evidence and relation to existing work + +`CLAIMS.json` preserves three exact source texts and JSON pointers. `SOURCES.json` binds the unchanged live canonical review files at base `7c49fe32c55de02c2c873655c804b16e4c3fef0a`; `VERIFY.json` declares all three for invalidation. The verifier pins bytes and checks pointer transcription, with positive and tamper controls. The written interpretation remains an inspectable source argument; the verifier is not a natural-language proof engine or an exception-safety test. + +[PR6321](https://github.com/CrocSwap/integer-mult-bounds/pull/6321) retains these original reviews. [PR6339](https://github.com/CrocSwap/integer-mult-bounds/pull/6339) addresses identity/ordinary cleanup; [PR6346](https://github.com/CrocSwap/integer-mult-bounds/pull/6346) adds narrow custody repairs. [PR6347](https://github.com/CrocSwap/integer-mult-bounds/pull/6347) gives conditional acquisition/raw-error/delivery witnesses. Those witnesses are not withdrawn; they must not be promoted into an additional universal prerequisite for the narrower original source review. This contribution neither requires nor replays the unmerged PR6346/6347 packages. + +## Reproduce the bounded audit + +```sh +python3 -B scripts/research_package.py --package research/h25-g12-original-contract-scope --check-only +python3 -B scripts/research_package.py --package research/h25-g12-original-contract-scope +``` + +Both registered normal/optimized commands inspect JSON and source bytes only. No archived target, Root, provider, compiler, native helper or original control is imported or executed. A passing replay is evidence-binding, not runtime qualification or independent human/proof-kernel acceptance. + +Original weighted completion remains43.5% (22/49), stage gates20%, milestones10%; no new body/family/activity, source adoption, O03, gain or kappa credit. All original selections remainNone. Unknown physical, preparation, review, publication and final metadata costs remain `OPEN_NOT_ZERO`. + +## Open next questions + +Review a concrete successor against the original obligations; see `TASK.json`. The smallest step is an exact caught-primary/secondary/cleanup source review, without adding a universal interpreter premise or generic accounting framework. + +## Credit + +Chris R / Clear1nsight, with substantial OpenAI Codex and ChatGPT Pro assistance. Retain the original PR6321/6029/5864 authors and source reviewers, unpaidmoon with Cursor Grok assistance for PR6339, and Douglas R. Colkitt's circuit/network/verification lineage. Canonical predecessor files remain unchanged. New analysis and verifier: Apache-2.0. diff --git a/research/h25-g12-original-contract-scope/SOURCES.json b/research/h25-g12-original-contract-scope/SOURCES.json new file mode 100644 index 0000000000..f840a5cb70 --- /dev/null +++ b/research/h25-g12-original-contract-scope/SOURCES.json @@ -0,0 +1,36 @@ +{ + "schema_version": 1, + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a", + "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "research/h25-cache-source-handoff/snapshot/review/cache-s0308-source-completion-v2/g12-protocol-independent/G12-CANDIDATE-PROTOCOL-REVIEW-v1.json", + "usage": "input", + "git_blob": "583dfc3936d478ffba6726470b454d0d99247b37", + "sha256": "feecd63be55243fe2a7d07da8ac1f7cfcec6558362e694b82219a1be232ab7bc" + }, + { + "path": "research/h25-cache-source-handoff/snapshot/review/cache-s0308-source-completion-v2/g12-protocol-independent/G12-CANDIDATE-PROTOCOL-REVIEW-v2.json", + "usage": "input", + "git_blob": "80d9b3e7d4d9657cd73875d06727a98d6360d612", + "sha256": "9b9043fa83f1a052a6708105431db20efd37b88bc0f23adc36491edd27b867ee" + }, + { + "path": "research/h25-cache-source-handoff/snapshot/review/cache-s0308-source-completion-v2/g12-custody-independent/G12-CUSTODY-SOURCE-SCOPE-CLARIFICATION-v1.json", + "usage": "input", + "git_blob": "66737f17c039d7157233648c46e0192e50e0e2dc", + "sha256": "a9261f686d4fbe6ca40258335231a730dc7e3319be7cedf7c39e189a57c7f367" + } + ] +} diff --git a/research/h25-g12-original-contract-scope/TASK.json b/research/h25-g12-original-contract-scope/TASK.json new file mode 100644 index 0000000000..434e4b1d42 --- /dev/null +++ b/research/h25-g12-original-contract-scope/TASK.json @@ -0,0 +1,60 @@ +{ + "schema_version": 1, + "task_id": "portable-replay", + "priority_revision": 8, + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "original_card": { + "id": "portable-replay", + "question": "Can one reproducible environment or artifact-comparison failure be repaired?", + "starting_points": [ + "research/gzip-container-reproducibility/README.md", + "docs/ci-verification.md" + ], + "methods": [ + "Reproduce one portability failure and add a minimal cross-environment fix.", + "Audit one canonical-payload comparison for omitted proof-relevant fields." + ], + "acceptance_gate": "Preserve immutable source hashes and proof-relevant content; a different compressed byte stream alone is not a mathematical mismatch.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "first_experiment": "Reproduce one specific mismatch or audit one canonical comparison for omitted proof-relevant fields.", + "bottleneck_link": "Portable exact checks prevent environment failures from blocking valid contributions.", + "allowed_variations": [ + "One interpreter/version mismatch or one payload field comparison." + ], + "scope_change_triggers": [ + "Removing immutable-source pins because generated compressed bytes differ." + ], + "overlap_terms": [ + "gzip container", + "reproducibility", + "canonical payload" + ] + }, + "scope_status": "changed", + "actual_scope": "Resolve the original G12 review scope: preserve an already-caught primary against new bookkeeping failures; neither a universal interpreter allocation-equivalence proof nor a newly constructed enclosing financial API is imposed by those source reviews. Preserve real original obligations and conditional PR6347 findings.", + "scope_change_reason": "Explicit user assignment to publish all resolved P07/G12 and V03 source questions, then consult Pro on C05. The retained card is provenance, not a claim to repair the selected supplier.", + "bottleneck_link": "Source-bound verifier qualification prerequisites; no change to the multiplication supplier, selected result or framework assumptions.", + "budget_minutes": 60, + "stop_rule": "Stop on source mismatch or unresolved interpretation; no target/native/compiler/original-control execution, historical allowance transfer or silent scope change.", + "outcome": "partial", + "evidence": "README.md, CLAIMS.json, exact source inputs and passive verifier with discriminating tamper controls.", + "author": "Chris R / Clear1nsight", + "ai_assistance": "ChatGPT Pro source consultation and substantial OpenAI Codex source-audit/verification assistance. These are agent-assisted findings, not human or proof-kernel acceptance.", + "open_questions": [ + { + "question": "Does a concrete successor preserve every original caught-primary, raw-secondary, ownership, cleanup and caller requirement?", + "why_it_matters": "Removing an invented prerequisite does not accept the rejected integration or complete S03.08.", + "first_step": "Review a separate exact successor against original CP01-CP15 and all18 branch obligations; keep source, runtime, cost and adoption dispositions separate.", + "blocked_by": "The remaining integrated implementation and original qualification have not been established." + } + ] +} diff --git a/research/h25-g12-original-contract-scope/VALIDATION.json b/research/h25-g12-original-contract-scope/VALIDATION.json new file mode 100644 index 0000000000..f487e747d5 --- /dev/null +++ b/research/h25-g12-original-contract-scope/VALIDATION.json @@ -0,0 +1,16 @@ +{ + "schema": "h25-resolved-source-validation-v1", + "observed_utc": "2026-11-02T03:05:04.863955+00:00", + "python": "3.12.3", + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "metadata_and_pins": "PASS", + "registered_normal": "PASS", + "registered_optimized": "PASS", + "summary": "3 pinned canonical review inputs;6 tamper controls in normal/optimized mode", + "source_findings_review": "Complete ChatGPT Pro source responses assessed against exact source by Codex. New verifier is a passive evidence check, not independent human or proof-kernel acceptance.", + "target_imports_or_execution": false, + "native_or_compiler_work": false, + "original_controls_executed": false, + "full_family_or_activity_credit": false, + "costs": "OPEN_NOT_ZERO" +} diff --git a/research/h25-g12-original-contract-scope/VERIFY.json b/research/h25-g12-original-contract-scope/VERIFY.json new file mode 100644 index 0000000000..ecf56f51fa --- /dev/null +++ b/research/h25-g12-original-contract-scope/VERIFY.json @@ -0,0 +1,38 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/h25-cache-source-handoff/snapshot/review/cache-s0308-source-completion-v2/g12-protocol-independent/G12-CANDIDATE-PROTOCOL-REVIEW-v1.json", + "research/h25-cache-source-handoff/snapshot/review/cache-s0308-source-completion-v2/g12-protocol-independent/G12-CANDIDATE-PROTOCOL-REVIEW-v2.json", + "research/h25-cache-source-handoff/snapshot/review/cache-s0308-source-completion-v2/g12-custody-independent/G12-CUSTODY-SOURCE-SCOPE-CLARIFICATION-v1.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 30, + "checks": "Passive source/byte evidence and tamper controls only; archived modules are never imported, compiled or executed. No runtime/family/activity qualification." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 30, + "checks": "Passive source/byte evidence and tamper controls only; archived modules are never imported, compiled or executed. No runtime/family/activity qualification." + } + ] +} diff --git a/research/h25-g12-original-contract-scope/verify.py b/research/h25-g12-original-contract-scope/verify.py new file mode 100644 index 0000000000..33221c9ce0 --- /dev/null +++ b/research/h25-g12-original-contract-scope/verify.py @@ -0,0 +1,104 @@ +"""Passive review-text binding. Never execute a predecessor or target module.""" +from pathlib import Path +import copy +import hashlib +import json + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parent.parent + + +def need(condition, message): + if condition is not True: + raise RuntimeError(message) + + +def pointer(value, path): + for key in path.split('/')[1:]: + value = value[int(key)] if type(value) is list else value[key] + return value + + +def inspect_scope(documents, claims): + rows = claims['resolved'] + need([row['id'] for row in rows] == [ + 'G12-CAUGHT-PRIMARY', 'G12-SOURCE-BOUNDARY', 'G12-NO-NEW-FINANCIAL-API'], + 'claim identity/order changed') + for row in rows: + need(pointer(documents[row['input']], row['pointer']) == row['source_text'], + 'source text transcription differs') + need('already-caught P' in rows[0]['source_text'] and + 'No broader allocation-equivalence proof or new authority framework is required.' in rows[0]['source_text'], + 'original narrow review instruction missing') + need('already-caught primary' in rows[1]['source_text'] and + 'not a universal allocation-equivalence proof' in rows[1]['source_text'], + 'static/runtime source boundary missing') + need('do not require construction of a new enclosing financial/accounting API' in rows[2]['source_text'] and + 'complete source work/cost bill' in rows[2]['source_text'], + 'original financial/API distinction missing') + need(claims['conditional_PR6347_witnesses_withdrawn'] is False and + claims['new_runtime_or_activity_acceptance'] is False, + 'unearned acceptance or witness retraction') + need(claims['original_weighted_activity_percent'] == 43.5 and + claims['original_complete_activities'] == 22 and + claims['original_activity_denominator'] == 49 and + claims['stage_gate_percent'] == 20 and claims['overall_milestone_percent'] == 10, + 'original denominators/credit changed') + need(claims['costs'] == 'OPEN_NOT_ZERO', 'unknown costs erased') + + +def rejected(action, label): + try: + action() + except (RuntimeError, KeyError, IndexError): + return + raise RuntimeError('tamper accepted: ' + label) + + +def main(): + sources = json.loads((HERE / 'SOURCES.json').read_text()) + docs = {} + for row in sources['files']: + if row['usage'] != 'input': + continue + raw = (ROOT / row['path']).read_bytes() + need(hashlib.sha256(raw).hexdigest() == row['sha256'], 'live source pin differs') + docs[row['path']] = json.loads(raw) + claims = json.loads((HERE / 'CLAIMS.json').read_text()) + inspect_scope(docs, claims) + count = 0 + # Change both the evidence transcription and decoded source: the scope + # anchors still reject a matching but materially broadened contract. + for index, before, after in [ + (0, 'No broader allocation-equivalence proof or new authority framework is required.', + 'A broader allocation-equivalence proof is required.'), + (1, 'not a universal allocation-equivalence proof', 'a universal allocation-equivalence proof'), + (2, 'do not require construction', 'require construction'), + ]: + bad_docs, bad_claims = copy.deepcopy(docs), copy.deepcopy(claims) + row = bad_claims['resolved'][index] + changed = row['source_text'].replace(before, after) + need(changed != row['source_text'], 'tamper placement failed') + row['source_text'] = changed + parts = row['pointer'].split('/')[1:] + parent = bad_docs[row['input']] + for key in parts[:-1]: + parent = parent[int(key)] if type(parent) is list else parent[key] + parent[parts[-1]] = changed + rejected(lambda: inspect_scope(bad_docs, bad_claims), str(index)) + count += 1 + for key in ('conditional_PR6347_witnesses_withdrawn', 'new_runtime_or_activity_acceptance'): + bad = copy.deepcopy(claims) + bad[key] = True + rejected(lambda: inspect_scope(docs, bad), key) + count += 1 + bad = copy.deepcopy(claims) + bad['resolved'][0]['source_text'] += ' unbound transcription' + rejected(lambda: inspect_scope(docs, bad), 'transcription') + count += 1 + print('PASS_G12_ORIGINAL_CONTRACT_SCOPE source_inputs=3 tamper_controls=' + str(count) + + ' target_execution=false original_acceptance=false') + + +if __name__ == '__main__': + main()