Release v0.1.1 real-patch evaluation tooling

Add local exact-execution baseline tooling, source, contract, and accurate development-result documentation. Existing controller candidates, runtime, and examples are unchanged.

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.1.1 — 1 October 2026
+
+Adds a separate `evaluation/real-patch/` tooling component within the same Laxmi release: an exact visible-source baseline wheel, source, versioned input contract and design-only private API draft. One exposed development case is scored correctly by exact execution; five other historical cases remain oracle-only. No learned real-patch model, blind result, hosted API, Linux exact-execution qualification or case dataset is released.
+
+All four controller candidate weights, metadata, runtime wheel/source ZIP and retained examples are byte-identical to v0.1.0. The controller experiment's failed repair and scientific scope are unchanged.
+
 ## 0.1.0 — 29 September 2026
 
 First public experimental controller package. Retains all four original September 15–16 candidates without selecting a winner or changing weights. Includes the negative development result, a smaller reviewed source closure, Apache 2.0 attribution, and a retained synthetic H1 installation/replay example.

CITATION.cff

@@ -13,5 +13,5 @@ abstract: >-
   consequences from observed state, history, actions and proposed code changes.
   Controlled experiments and reproducibility infrastructure do not establish
   general software-engineering capability or production suitability.
-version: "0.1.0"
-date-released: 2026-09-29
+version: "0.1.1"
+date-released: 2026-10-01

README.md

@@ -6,6 +6,7 @@ tags:
   - experimental
   - negative-results
   - custom-model
+  - real-patch-evaluation
 ---
 
 # Laxmi — experimental software-state prediction
@@ -14,11 +15,11 @@ tags:
 
 Created and maintained by **Navneet Prabhakar**, creator and sole contributor to Laxmi. Third-party libraries retain their authorship and licenses.
 
-Laxmi investigates whether observed software state, history, an action and a proposed code change can predict what happens next. This first release makes a bounded controller experiment inspectable and runnable. It is not a chat model, a general code-review assistant or an autonomous software engineer.
+Laxmi investigates whether observed software state, history, an action and a proposed code change can predict what happens next. This release keeps the bounded controller experiment inspectable and adds local real-patch evaluation tooling to the **same research project**. It is not a chat model, a general code-review assistant or an autonomous software engineer.
 
-> **Version 0.1.0 · Experimental research release**
+> **Version 0.1.1 · Experimental research release**
 >
-> The consumer works on the verified installation scope. The latest model repair failed its improvement test. All four candidates are retained; none is promoted as an accepted model.
+> Controller weights and runtime are unchanged from v0.1.0. The latest model repair failed its improvement test. The new real-patch exact-execution tool is a baseline, **not a trained model**. None of the four controller candidates is promoted as an accepted model.
 
 ## The experiment
 
@@ -47,14 +48,18 @@ Readout normalization did not improve the task. These are exposed development re
 
 The packaged example checks installation and replay. It must not be presented as a fresh benchmark. See [verification.json](verification.json) for the exact smoke scope and [BENCHMARK.md](BENCHMARK.md) for the next comparison design.
 
+### Real-patch development screen
+
+This release also contains [local real-patch evaluation tooling](evaluation/real-patch/README.md). Six exposed historical changes were inventoried; only one currently has a valid forecast packet, and five have oracle-only scenarios excluded from forecast accuracy. On the one scored development case, the **same-information exact-execution baseline** matched both branch observations and the patch effect. The scenario was selected after its outcome was known. There are no blind/acceptance-eligible cases, no learned real-patch model scored, and no released case data. The result shows that this fully runnable case offers no measured headroom over exact execution; it does not validate generalization.
+
 ## Download and run
 
-**Verified platform: Apple Silicon macOS, Python 3.12.11.** The wheel is macOS ARM64 tagged. Other Python 3.12 patch builds and platforms have not been verified. The source archive is provided for inspection and experimentation; it does not establish Linux support. No GPU is required for the example.
+**Controller runtime verified platform: Apple Silicon macOS, Python 3.12.11.** That wheel is macOS ARM64 tagged. Other Python 3.12 patch builds and platforms have not been verified for the controller runtime. The source archive is provided for inspection and experimentation; it does not establish Linux controller support. No GPU is required for the example.
 
 With the Hugging Face `hf` CLI installed:
 
 ```bash
-hf download Executespec/laxmi-controller-experimental --revision v0.1.0 --local-dir laxmi-release
+hf download Executespec/laxmi-controller-experimental --revision v0.1.1 --local-dir laxmi-release
 cd laxmi-release
 shasum -a 256 -c SHA256SUMS
 python3.12 -m venv .venv
@@ -66,12 +71,15 @@ Expected completion: `17-original: all six operations passed`. The output direct
 
 The wheel declares exact dependency versions, also recorded in `requirements-macos-arm64-py312.txt`. Dependencies are installed separately; they are not bundled. Version pins are not a dependency artifact hash lock. The source package includes the runtime source and license files. No optimizer checkpoint is shipped.
 
+The separate real-patch package has its own [local installation instructions](evaluation/real-patch/README.md). It installed and **validated** its input in an offline Linux ARM64 container, but Linux exact execution and any hosted API remain unqualified. Its OpenAPI file is a design draft only.
+
 ## Package layout
 
 | Path | Contents |
 |---|---|
 | `candidates/17-original/`, `17-normalized/`, `43-original/`, `43-normalized/` | Original retained safetensors weights, configuration, manifests and matching consumer metadata |
 | `runtime/` | Reviewed runtime wheel and source ZIP |
+| `evaluation/real-patch/` | Local exact-baseline evaluator wheel, source, contract and design-only API draft; no model weights or case data |
 | `examples/` | One retained synthetic observation, proposal comparison and outcome template |
 | `verify_release.py` | Installation/replay check using only this package |
 | `release.json`, `SHA256SUMS` | Candidate identity, runtime identity and file integrity |
@@ -90,6 +98,7 @@ Weights, configuration, readout metadata and runtime must match. Original and no
 - Longer rollouts may contain unresolved/pruned probability mass; it is not silently renormalized away.
 - Supported consumer horizons are 1, 2, 4 and 8; this release's installation smoke covers H1 only.
 - The learned probabilities are not proven calibrated and do not authorize external actions.
+- The real-patch exact comparator is a baseline, not learned prediction. Only one exposed development forecast was scored; no public API or Linux exact-execution qualification exists.
 
 ## Benchmark and iteration
 

RELEASE_SCOPE.md

@@ -9,3 +9,9 @@ The runtime closure consists of original Laxmi source files extracted byte-for-b
 Dependencies such as PyTorch, NumPy, safetensors and jsonschema are referenced as installation requirements and are not bundled. Their licenses and copyright holders remain applicable; Laxmi does not claim their authorship. The source ZIP contains the package manifest, Python sources, required original configuration/schema, build files and Laxmi license/notice files.
 
 Repository-wide datasets and other artifacts outside this distribution receive no new redistribution grant from this release. Scientific model qualification remains open despite publication. License selection and distribution permission do not establish model accuracy or independence of evaluation.
+
+## v0.1.1 extension
+
+The `evaluation/real-patch/` directory adds original Laxmi source, schema, documentation and a local wheel built from the source at commit `63cbecbad1bd8832d9c4fae65e4cfad27c57fa76`. These authored files are included under Apache 2.0, with exact file bytes enumerated by SHA256SUMS. The component contains no third-party repository code, real-patch case inputs, oracles, learned weights, corpus, private operational data or credentials. The public six-case counts and one-case exact-baseline result are summaries of exposed development evidence, not a distributed benchmark dataset.
+
+The existing four controller candidates, matching runtime artifacts and synthetic example bytes are unchanged from v0.1.0. The new OpenAPI file describes a possible private service; no HTTP service is deployed or licensed as a maintained public endpoint. The wheel's Linux install/validation receipt does not establish Linux exact execution. Dependencies remain external with their own terms.

SHA256SUMS

@@ -1,11 +1,11 @@
 78080e2966ee7383e24c55bf5ddd9e895fc80bdf9d2bb69de996e3d0b18f8cfb  BENCHMARK.md
-15d87975bbf97b56e3377d82f57e76e210d156ddcf26d34184e34990af8e6c7f  CHANGELOG.md
-d5de9a7a59d6618ca67413f9a5991dfb8785fb2ac1c82de9b8be4e99a407337a  CITATION.cff
+f6e111f7762997f2a1310f08707a5af146615dab7b6f076d803dc92a517f1196  CHANGELOG.md
+f42243d8ec7031d491961ebcbe70b70c9d410b1964f2080c73c4ab03bc9b01d8  CITATION.cff
 cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30  LICENSE
 3a66b62901c108c4f8946247ff7a773f73ac3bcec0b8a34286eb921164e97d5f  LICENSE_SCOPE.md
 3baa95979dcbe90444a854d04bbb6546c799e2077d9a69cfa34014a5c6512950  NOTICE
-6a64cd7750ed0b39dbb3558ce1a74a41f509ab680ae3991b13c2bd0d5e101810  README.md
-73b3b48727cd9b100cef2e20a9eb5feaf4d2ac8859bbb1b31d8e66bf5aae0d59  RELEASE_SCOPE.md
+af5cdcd4819c7997c61a1f19f1dbff5a4b254547ae6395f88964e0b0e6d5c24a  README.md
+f7dbdd9349019149fc54ae8bcf3edf442d5b53a62bf0905b57b88a1e3379a48c  RELEASE_SCOPE.md
 225a71bb67d619e70f1aec0313d2c5791d0a94ac3942297ad12ba284269cddd8  candidates/17-normalized/consumer.json
 05478c5c7bf33bce2df7f7b1ffdffaa11dab3d6220558b1c2bb4d8432a5230e7  candidates/17-normalized/inference/config.json
 e12fd2cc04ad23ae6b1c8937652a56fc08cac040e56a3f411e3388da6b4eb6b5  candidates/17-normalized/inference/manifest.json
@@ -23,10 +23,23 @@ b01a8a82dc6c7881b439006d6e24a60a40e59a4416ff9719ad34611c205af87c  candidates/43-
 d78f08c415e769d3e2676927e709c22d535a32ea5c79c6252ce0575af4abbcfd  candidates/43-original/inference/manifest.json
 604d14c55256a7dd3c8f56072eda97fd7517912bd4d965d416d76040428261cb  candidates/43-original/inference/model.safetensors
 ec1b954a497b276bb1806fbfcabde6e363f495f9dda60b1e686339a68bddd52d  download-verification.json
+c9693a57855ca9af6ff2f0ab681d3f7902b164dccc93602e6d58d22e8eecda0e  evaluation/real-patch/README.md
+a36e136b730b9b941af303ca23dcdaaff0268b3e3dfafab4122730ee45d8da0e  evaluation/real-patch/runtime/laxmi_real_patch-0.1.0.dev1-py3-none-any.whl
+cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30  evaluation/real-patch/source/LICENSE
+3a66b62901c108c4f8946247ff7a773f73ac3bcec0b8a34286eb921164e97d5f  evaluation/real-patch/source/LICENSE_SCOPE.md
+3baa95979dcbe90444a854d04bbb6546c799e2077d9a69cfa34014a5c6512950  evaluation/real-patch/source/NOTICE
+77aa1eb34fb78016565afcce6a27bbe18561bea3652544ac50107e5c770b45cd  evaluation/real-patch/source/code_review/contracts/real_patch_api_v1/openapi.yaml
+06a5bb4ca539bcb95ff97f58d2a003107b03a5af2a0b2fe21643d0c75590e1c0  evaluation/real-patch/source/code_review/contracts/real_patch_prediction_v1/README.md
+ddd2f1a6f908334d4111971a14810fd5393d1735a00a39c3e745dd9d0f3d018c  evaluation/real-patch/source/code_review/contracts/real_patch_prediction_v1/forecast_request.schema.json
+23b973a4fdd00e148254723cbcada5be02c65e80818cba6b1f0f3dbd42cc6a55  evaluation/real-patch/source/code_review/contracts/real_patch_prediction_v1/validator.py
+ef8e9e728670c20a75dfc50a26649a073d4d04943791dc02a3b4a3e73af9f3e7  evaluation/real-patch/source/code_review/packaging/real_patch/api.py
+a9a3cf605b0f34de4f0dcde1a9378682a3fd9149dc112152c3cf418aa2a9df4e  evaluation/real-patch/source/code_review/scripts/build_real_patch_local_package_v1.py
+8538931b8044a98b1f245aaba4ec281b71a10e30944a46baf6ec34a4c659d9c8  evaluation/real-patch/source/code_review/scripts/run_real_patch_baseline_gate_v2.py
+6344b680488213d222cca267f47ed54dcfecb0b1b4990033b4785d808ee54e3a  evaluation/real-patch/source/code_review/scripts/run_real_patch_visible_exact_v1.py
 0d98c572630d61128ca07c4f92939597704ba8964d3f40f9d04bf60bab8f761f  examples/compare.json
 2032524a11a31ff92634369060ff5a41adc6bc993161d6eb47a25a4839756ad1  examples/input.json
 b208c06bd5829a5b18521711433338fdf2500ddcf312658c9d0b788b0fc0873c  examples/outcome-template.json
-d2552789b1d10160c7fd0446e6c5a4833f1816954e235b2edc2fc579e669ee9f  release.json
+0e02068ddc38d1f32f79c2003649695cf807857843784ebba179884e64ae8a69  release.json
 b3bb0efc5b695baf36d6959e650baaaf4dd5bd32c0d6189a355b05185d45ac80  requirements-macos-arm64-py312.txt
 67517f7c692d81580248e994c61829ddfdf2f9ef29358dd71a6b17eb953ef99f  runtime/laxmi-readout-runtime-capsule-0.1.0-source.zip
 47d03da88fa9bd9c1b4573ac4a0d5cb36c2cd1d106d687b68aa2968b713ee9b3  runtime/laxmi_readout_runtime_capsule-0.1.0-py3-none-macosx_11_0_arm64.whl

evaluation/real-patch/README.md

@@ -0,0 +1,37 @@
+# Real-patch development evaluation tooling
+
+This directory is part of **Laxmi experimental release v0.1.1**, maintained by Navneet Prabhakar. It is a tooling extension to the same Laxmi research project, not another model. The controller model weights and runtime remain byte-identical to v0.1.0. This directory contains **no learned real-patch weights**, user source, candidate data or oracle records.
+
+The local package validates a paired pre-execution forecast request, executes the unchanged and proposed-patch branches from the **same visible source, dependency and scenario bytes**, seals the prediction, and scores only through a separately invoked oracle operation. Exact execution is a baseline. Its success must not be credited to a learned world model.
+
+## Current evaluation
+
+Six exposed historical changes are inventoried. Only one has a forecast packet under the current contract; the other five have oracle-only scenarios mostly adapted from post-change tests and are excluded from forecast accuracy. On that one exposed development case, exact execution matched both branch observations and the change effect. There are zero blind/acceptance-eligible cases and no learned real-patch candidate scored. The selected scenario was projected after the outcome was known. No evaluation case data is distributed in this release.
+
+## Local installation
+
+From the downloaded release root in a fresh Python 3.12 environment:
+
+```bash
+python3.12 -m venv .venv-real-patch
+.venv-real-patch/bin/python -m pip install evaluation/real-patch/runtime/laxmi_real_patch-0.1.0.dev1-py3-none-any.whl
+.venv-real-patch/bin/laxmi-real-patch validate --request /path/to/forecast_request.json
+```
+
+The [request contract](source/code_review/contracts/real_patch_prediction_v1/README.md) and [schema](source/code_review/contracts/real_patch_prediction_v1/forecast_request.schema.json) specify model-visible input. A request must have independently reviewed source/scenario provenance; passing schema validation cannot establish truth of self-declared timestamps or acceptance eligibility. The installed interface explicitly reports `custody_verified=false`, `acceptance_eligible=false` and `development_only=true`.
+
+`forecast` requires a **new** output directory and a suitable local Docker runtime with `python:3.12-slim` resolving to image ID `sha256:78387bc3881b8273120a12ebe6c1ab22b018ccc2c9adf565ae1ac9b536e184ea`:
+
+```bash
+.venv-real-patch/bin/laxmi-real-patch forecast --request /path/to/forecast_request.json --output-dir ./forecast-001
+```
+
+The comparator does not read oracles. A separately authorized evaluator can later score a sealed prediction:
+
+```bash
+.venv-real-patch/bin/laxmi-real-patch score --request /path/to/forecast_request.json --oracle /path/to/gate-oracle.json --output-dir ./forecast-001
+```
+
+The wheel SHA-256 is `a36e136b730b9b941af303ca23dcdaaff0268b3e3dfafab4122730ee45d8da0e`. A fresh macOS ARM64 Python 3.12 install reproduced the original prediction and score receipt bytes. Offline Linux ARM64 installation and **validation** returned the same request hash; Linux exact execution was not qualified. The wheel tag `py3-none-any` is packaging metadata, not a blanket portability claim. The exact comparator executes supplied scenario code in an isolated local Docker container; do not expose this CLI as a public code-execution service.
+
+The [OpenAPI document](source/code_review/contracts/real_patch_api_v1/openapi.yaml) is **design-only**. There is no hosted API, authenticated job service or production deployment. Source files and the builder are provided under [`source/`](source/) for inspection; build the wheel from that directory with `python code_review/scripts/build_real_patch_local_package_v1.py --output-dir /new/output`. The root [LICENSE](../../LICENSE), [NOTICE](../../NOTICE), [RELEASE_SCOPE.md](../../RELEASE_SCOPE.md) and [SHA256SUMS](../../SHA256SUMS) govern this release.

evaluation/real-patch/source/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

evaluation/real-patch/source/LICENSE_SCOPE.md

@@ -0,0 +1,38 @@
+# Licensing scope
+
+Copyright 2026 Navneet Prabhakar.
+
+Navneet Prabhakar's original Laxmi source code, documentation, configuration,
+schemas and authored test fixtures are licensed under Apache License 2.0,
+unless an individual file explicitly states different terms. LICENSE contains
+the unmodified license text; NOTICE records project attribution. Future accepted
+contributions follow the license's contribution terms unless separately agreed.
+
+Apache 2.0 is also the selected license for original Laxmi model weights shipped
+in an explicitly identified release after provenance and redistribution review.
+Every model release must identify its exact weights and applicable terms. The
+presence of a local checkpoint does not alone establish its release eligibility.
+
+The repository license does not relicense third-party source, dependencies,
+models, tokenizers, copied documents or other third-party material. Their existing
+terms and required notices remain applicable. Incorporating or linking a dependency
+does not claim its authorship or change its license.
+
+Acquired corpora, datasets, repository clones, training/evaluation records,
+operational archives and generated evidence under data/, results/, archive/ and
+the corresponding code_review/ directories are not granted redistribution rights
+by this repository license alone. Individual released datasets or artifact bundles
+require an explicit scope manifest and their applicable terms. Original source or
+documentation in those directories may be expressly included in such a manifest.
+Private inputs, credentials and operational records are not public release assets.
+
+## Attribution and citation
+
+Redistributors must comply with Apache 2.0's license and applicable notice
+preservation requirements. The NOTICE file provides Laxmi's attribution. It adds
+no requirement to display a badge, advertise the author or obtain permission for
+permitted uses. CITATION.cff makes a requested research citation convenient;
+citation is not an additional condition of the license.
+
+Navneet Prabhakar remains Laxmi's original creator. Contributor lists should
+reflect later accepted contributions if the project gains other contributors.

evaluation/real-patch/source/NOTICE

@@ -0,0 +1,12 @@
+Laxmi
+Copyright 2026 Navneet Prabhakar
+
+Created and maintained by Navneet Prabhakar.
+Project: https://github.com/navneetprabhakar/laxmi
+
+Laxmi's original contributions are licensed under the Apache License,
+Version 2.0. See LICENSE and LICENSE_SCOPE.md for applicable scope.
+
+Third-party libraries, models and other materials retain their respective
+copyrights, licenses and attribution requirements. This notice does not
+claim authorship of those materials or imply their authors' endorsement.

evaluation/real-patch/source/code_review/contracts/real_patch_api_v1/openapi.yaml

@@ -0,0 +1,251 @@
+openapi: 3.1.0
+info:
+  title: Laxmi real-patch private API
+  version: 0.1.0-design
+  description: >-
+    Design-only asynchronous transport over the real-patch forecast contract.
+    No hosted implementation, learned real-patch model, or public endpoint exists.
+x-implementation-status: DESIGN_ONLY
+paths:
+  /v1/real-patch/requests:validate:
+    post:
+      operationId: validateRealPatchRequest
+      summary: Validate model-visible input without execution or oracle access
+      security:
+        - bearerAuth: []
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: ../real_patch_prediction_v1/forecast_request.schema.json
+      responses:
+        '200':
+          description: Structural admission only; not proof of external provenance
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ValidationResult'
+        '422':
+          $ref: '#/components/responses/Refusal'
+  /v1/real-patch/forecast-jobs:
+    post:
+      operationId: submitRealPatchForecast
+      summary: Submit a sealed-before-outcome forecast job
+      security:
+        - bearerAuth: []
+      parameters:
+        - name: Idempotency-Key
+          in: header
+          required: true
+          schema:
+            type: string
+            minLength: 16
+            maxLength: 128
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              additionalProperties: false
+              required: [request, engine_id, engine_version]
+              properties:
+                request:
+                  $ref: ../real_patch_prediction_v1/forecast_request.schema.json
+                engine_id:
+                  type: string
+                  enum: [EXACT_VISIBLE_SOURCE, STATIC_RULES, RETRIEVAL, LEARNED]
+                engine_version:
+                  type: string
+      responses:
+        '202':
+          description: Create-only job accepted; no prediction is implied
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/JobStatus'
+        '409':
+          $ref: '#/components/responses/Refusal'
+        '422':
+          $ref: '#/components/responses/Refusal'
+  /v1/real-patch/forecast-jobs/{id}:
+    get:
+      operationId: getRealPatchForecastJob
+      security:
+        - bearerAuth: []
+      parameters:
+        - $ref: '#/components/parameters/JobId'
+      responses:
+        '200':
+          description: Job state, including unsupported and failed states
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/JobStatus'
+  /v1/real-patch/forecast-jobs/{id}/prediction:
+    get:
+      operationId: getSealedRealPatchPrediction
+      security:
+        - bearerAuth: []
+      parameters:
+        - $ref: '#/components/parameters/JobId'
+      responses:
+        '200':
+          description: Prediction receipt without oracle or score
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/PredictionResult'
+        '409':
+          $ref: '#/components/responses/Refusal'
+  /v1/real-patch/outcomes:
+    post:
+      operationId: attachRealPatchOutcome
+      summary: Privileged evaluator attaches observed outcome after forecast seal
+      security:
+        - evaluatorAuth: []
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              additionalProperties: false
+              required: [job_id, oracle_sha256, oracle_ref]
+              properties:
+                job_id:
+                  type: string
+                oracle_sha256:
+                  $ref: '#/components/schemas/Sha256'
+                oracle_ref:
+                  type: string
+                  description: Evaluator-only immutable artifact reference
+      responses:
+        '201':
+          description: Outcome attached immutably after sealed prediction
+        '409':
+          $ref: '#/components/responses/Refusal'
+  /v1/real-patch/evaluations/{id}:
+    get:
+      operationId: getRealPatchEvaluation
+      summary: Retrieve an evaluator-only score and eligibility receipt
+      security:
+        - evaluatorAuth: []
+      parameters:
+        - $ref: '#/components/parameters/JobId'
+      responses:
+        '200':
+          description: Scored result with the attempted-case denominator
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/EvaluationResult'
+components:
+  securitySchemes:
+    bearerAuth:
+      type: http
+      scheme: bearer
+    evaluatorAuth:
+      type: http
+      scheme: bearer
+      description: Separate evaluator principal with outcome-storage access
+  parameters:
+    JobId:
+      name: id
+      in: path
+      required: true
+      schema:
+        type: string
+  schemas:
+    Sha256:
+      type: string
+      pattern: '^[0-9a-f]{64}$'
+    ValidationResult:
+      type: object
+      additionalProperties: false
+      required: [status, input_sha256, custody_verified, acceptance_eligible]
+      properties:
+        status:
+          const: ADMITTED
+        input_sha256:
+          $ref: '#/components/schemas/Sha256'
+        custody_verified:
+          const: false
+        acceptance_eligible:
+          const: false
+    JobStatus:
+      type: object
+      additionalProperties: false
+      required: [job_id, status, input_sha256, engine_id, engine_version]
+      properties:
+        job_id:
+          type: string
+        status:
+          enum: [QUEUED, RUNNING, PREDICTED, UNSUPPORTED, FAILED]
+        input_sha256:
+          $ref: '#/components/schemas/Sha256'
+        engine_id:
+          type: string
+        engine_version:
+          type: string
+        reason_code:
+          type: string
+    PredictionResult:
+      type: object
+      additionalProperties: false
+      required: [job_id, status, input_sha256, engine_id, method_sha256, information_tier, observations, seal_sha256]
+      properties:
+        job_id:
+          type: string
+        status:
+          const: PREDICTED
+        input_sha256:
+          $ref: '#/components/schemas/Sha256'
+        engine_id:
+          type: string
+        method_sha256:
+          $ref: '#/components/schemas/Sha256'
+        information_tier:
+          enum: [SAME_INFORMATION, PRIVILEGED_CEILING]
+        observations:
+          type: object
+          description: Exactly the declared branch fields from the validated request
+        seal_sha256:
+          $ref: '#/components/schemas/Sha256'
+    EvaluationResult:
+      type: object
+      additionalProperties: false
+      required: [evaluation_id, evaluation_split, dataset_sha256, candidate_count, scored_case_count, unsupported_case_count, receipt_sha256]
+      properties:
+        evaluation_id:
+          type: string
+        evaluation_split:
+          enum: [DEVELOPMENT_EXPOSED, ACCEPTANCE_CANDIDATE]
+        dataset_sha256:
+          $ref: '#/components/schemas/Sha256'
+        candidate_count:
+          type: integer
+          minimum: 1
+        scored_case_count:
+          type: integer
+          minimum: 0
+        unsupported_case_count:
+          type: integer
+          minimum: 0
+        receipt_sha256:
+          $ref: '#/components/schemas/Sha256'
+  responses:
+    Refusal:
+      description: Request refused without a prediction
+      content:
+        application/json:
+          schema:
+            type: object
+            additionalProperties: false
+            required: [error, reason_code]
+            properties:
+              error:
+                type: string
+              reason_code:
+                type: string

evaluation/real-patch/source/code_review/contracts/real_patch_prediction_v1/README.md

@@ -0,0 +1,38 @@
+# Real-patch forecast input v1
+
+`forecast_request.schema.json` defines the **entire model-visible request** for a
+pre-execution forecast. `validator.py` additionally checks content hashes,
+chronology, source/patch lineage, duplicate identities and patch file roles.
+All consumers receive the same canonical request bytes; `shared_input.input_sha256`
+is SHA-256 of canonical JSON excluding `shared_input` itself. Canonical JSON uses
+sorted keys, compact separators, UTF-8, and no non-finite numbers. A comparator
+may report `unsupported`, but may not substitute more informative material.
+
+The request contains an opaque repository alias and a hash of the visible source
+file manifest. Explicit repository URL, Git commit, issue locator, selection notes,
+PR metadata, oracle code/results and any future test metadata live in a **separate custody
+record** that must never be passed to a forecast consumer. Pinned source bytes
+may themselves contain public repository identifiers; opaque metadata does not
+remove this contamination risk. The visible proposed
+diff may change production files only; tests and fixtures are rejected. Scenario
+input is structured as entrypoint plus JSON arguments, with an artifact hash and
+availability timestamp. The same sanitized Python `program` bytes are visible
+to every comparator and bind the exact runner; an AST check rejects assertions
+and obvious expected-value variables. There is no field for issue prose,
+expected values, diagnosis, PR title/body, or post-patch result. Pre-patch history can
+include observed outcomes on the pinned base source only.
+
+The schema cannot prove that a timestamp is true, that a source slice really
+comes from the claimed immutable snapshot, or that a string argument encodes no
+answer. An assembler must verify external artifact timestamps, version history,
+licenses, patch provenance and scenario selection against the custody record
+before signing a case. A reviewer must inspect each assembled packet for semantic
+leakage. Historical public code may still be memorized by a pretrained model;
+opaque IDs reduce direct lookup, but do not establish contamination freedom.
+
+`target` requires paired `NO_CHANGE` and `PROPOSED_PATCH` branches under the
+same invocation and bounded completion horizon. It declares observable fields
+and the categorical vocabulary, never their values. The sealed oracle and
+predictor outputs are separate files. This contract
+does not itself establish that a learned predictor beats exact execution, static
+rules or retrieval.

evaluation/real-patch/source/code_review/contracts/real_patch_prediction_v1/forecast_request.schema.json

@@ -0,0 +1,137 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://laxmi.local/contracts/real-patch-prediction/v1/forecast-request.schema.json",
+  "title": "Real patch pre-execution forecast request v1",
+  "description": "Model-visible information only. Oracle, PR-added tests, expected assertions, diagnoses and post-patch outcomes belong in separate sealed records.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "case_id", "evaluation_split", "forecast_cutoff_at", "pre_source", "proposed_patch", "scenario", "operating_conditions", "history", "target", "shared_input"],
+  "properties": {
+    "schema_version": {"const": "1.0.0"},
+    "case_id": {"$ref": "#/$defs/id"},
+    "evaluation_split": {"enum": ["DEVELOPMENT_EXPOSED", "ACCEPTANCE_CANDIDATE"]},
+    "forecast_cutoff_at": {"$ref": "#/$defs/timestamp"},
+    "pre_source": {
+      "type": "object", "additionalProperties": false,
+      "required": ["repository_alias", "snapshot_sha256", "snapshot_at", "files"],
+      "properties": {
+        "repository_alias": {"$ref": "#/$defs/id"},
+        "snapshot_sha256": {"$ref": "#/$defs/sha256"},
+        "snapshot_at": {"$ref": "#/$defs/timestamp"},
+        "files": {"type": "array", "minItems": 1, "items": {"$ref": "#/$defs/sourceFile"}}
+      }
+    },
+    "proposed_patch": {
+      "type": "object", "additionalProperties": false,
+      "required": ["base_snapshot_sha256", "diff_sha256", "unified_diff", "proposed_at", "provenance"],
+      "properties": {
+        "base_snapshot_sha256": {"$ref": "#/$defs/sha256"},
+        "diff_sha256": {"$ref": "#/$defs/sha256"},
+        "unified_diff": {"type": "string", "minLength": 1},
+        "proposed_at": {"$ref": "#/$defs/timestamp"},
+        "provenance": {"const": "CANDIDATE_PATCH_AT_FORECAST"}
+      }
+    },
+    "scenario": {
+      "type": "object", "additionalProperties": false,
+      "required": ["origin", "available_at", "source_artifact_sha256", "selection_policy", "projection_policy", "program", "program_sha256", "setup_assignments", "invocations"],
+      "properties": {
+        "origin": {"enum": ["PRE_PATCH_WORKLOAD_TRACE", "PRE_PATCH_ISSUE_REPRO", "PRE_PATCH_TEST", "PROSPECTIVE_GENERATOR"]},
+        "available_at": {"$ref": "#/$defs/timestamp"},
+        "source_artifact_sha256": {"$ref": "#/$defs/sha256"},
+        "selection_policy": {"enum": ["FROZEN_BEFORE_OUTCOME", "RETROSPECTIVE_EXPOSED_DEVELOPMENT"]},
+        "projection_policy": {"const": "PRE_PATCH_INPUTS_WITHOUT_ASSERTIONS_OR_EXPECTED_OUTPUTS"},
+        "program": {"type": "string", "minLength": 1},
+        "program_sha256": {"$ref": "#/$defs/sha256"},
+        "setup_assignments": {"type": "array", "items": {"$ref": "#/$defs/assignment"}},
+        "invocations": {"type": "array", "minItems": 1, "items": {"$ref": "#/$defs/invocation"}}
+      }
+    },
+    "operating_conditions": {
+      "type": "object", "additionalProperties": false,
+      "required": ["python_version", "platform", "dependency_lock_sha256", "dependency_sources", "environment"],
+      "properties": {
+        "python_version": {"type": "string", "pattern": "^3\\.[0-9]+(?:\\.[0-9]+)?$"},
+        "platform": {"type": "string", "minLength": 1, "maxLength": 80},
+        "dependency_lock_sha256": {"$ref": "#/$defs/sha256"},
+        "dependency_sources": {"type": "array", "items": {"$ref": "#/$defs/sourceFile"}},
+        "environment": {"type": "object", "propertyNames": {"pattern": "^[A-Z][A-Z0-9_]*$"}, "additionalProperties": {"type": "string", "maxLength": 1024}}
+      }
+    },
+    "history": {"type": "array", "items": {"$ref": "#/$defs/historyEvent"}},
+    "target": {
+      "type": "object", "additionalProperties": false,
+      "required": ["kind", "branches", "horizon", "observation_classes", "observe"],
+      "properties": {
+        "kind": {"const": "PAIRED_INTERVENTION"},
+        "branches": {"const": ["NO_CHANGE", "PROPOSED_PATCH"]},
+        "horizon": {
+          "type": "object", "additionalProperties": false,
+          "required": ["kind", "max_seconds"],
+          "properties": {
+            "kind": {"const": "INVOCATION_COMPLETION"},
+            "max_seconds": {"type": "integer", "minimum": 1, "maximum": 3600}
+          }
+        },
+        "observation_classes": {"const": ["RETURN", "EXCEPTION", "TIMEOUT", "PROCESS_ERROR"]},
+        "observe": {"type": "array", "minItems": 1, "uniqueItems": true, "items": {"enum": ["observation_class", "return_value_sha256", "exception_type", "exit_code"]}, "contains": {"const": "observation_class"}}
+      }
+    },
+    "shared_input": {
+      "type": "object", "additionalProperties": false,
+      "required": ["input_sha256", "information_policy", "consumers"],
+      "properties": {
+        "input_sha256": {"$ref": "#/$defs/sha256"},
+        "information_policy": {"const": "IDENTICAL_REQUEST"},
+        "consumers": {"const": ["EXACT_EXECUTION", "STATIC_RULES", "RETRIEVAL", "LEARNED"]}
+      }
+    }
+  },
+  "$defs": {
+    "id": {"type": "string", "pattern": "^[a-z][a-z0-9._-]{2,127}$"},
+    "sha256": {"type": "string", "pattern": "^[0-9a-f]{64}$"},
+    "timestamp": {"type": "string", "format": "date-time"},
+    "path": {"type": "string", "pattern": "^(?!/)(?!.*(?:^|/)\\.\\.(?:/|$))[A-Za-z0-9._/-]+$"},
+    "sourceFile": {
+      "type": "object", "additionalProperties": false,
+      "required": ["path", "sha256", "content"],
+      "properties": {"path": {"$ref": "#/$defs/path"}, "sha256": {"$ref": "#/$defs/sha256"}, "content": {"type": "string"}}
+    },
+    "invocation": {
+      "type": "object", "additionalProperties": false,
+      "required": ["call_kind", "entrypoint", "args", "kwargs"],
+      "properties": {
+        "call_kind": {"enum": ["CONSTRUCTOR", "METHOD", "FUNCTION"]},
+        "entrypoint": {"type": "string", "pattern": "^[A-Za-z_][A-Za-z0-9_.:]*$"},
+        "receiver_ref": {"$ref": "#/$defs/id"},
+        "bind_result_as": {"$ref": "#/$defs/id"},
+        "args": {"type": "array", "items": {"$ref": "#/$defs/jsonValue"}},
+        "kwargs": {"type": "object", "propertyNames": {"pattern": "^[A-Za-z_][A-Za-z0-9_]*$"}, "additionalProperties": {"$ref": "#/$defs/jsonValue"}}
+      }
+    },
+    "assignment": {
+      "type": "object", "additionalProperties": false,
+      "required": ["target", "value"],
+      "properties": {
+        "target": {"type": "string", "pattern": "^[A-Za-z_][A-Za-z0-9_.]*$"},
+        "value": {"$ref": "#/$defs/jsonValue"}
+      }
+    },
+    "historyEvent": {
+      "type": "object", "additionalProperties": false,
+      "required": ["event_id", "observed_at", "source_snapshot_sha256", "origin", "invocation", "observation_class"],
+      "properties": {
+        "event_id": {"$ref": "#/$defs/id"},
+        "observed_at": {"$ref": "#/$defs/timestamp"},
+        "source_snapshot_sha256": {"$ref": "#/$defs/sha256"},
+        "origin": {"enum": ["PRE_PATCH_WORKLOAD_TRACE", "PRE_PATCH_BASE_EXECUTION"]},
+        "invocation": {"$ref": "#/$defs/invocation"},
+        "observation_class": {"enum": ["RETURN", "EXCEPTION", "TIMEOUT", "PROCESS_ERROR"]},
+        "return_value_sha256": {"$ref": "#/$defs/sha256"},
+        "exception_type": {"type": "string", "pattern": "^[A-Za-z_][A-Za-z0-9_.]*$"},
+        "exit_code": {"type": "integer", "minimum": 0, "maximum": 255}
+      }
+    },
+    "jsonValue": {"anyOf": [{"type": "null"}, {"type": "boolean"}, {"type": "number"}, {"type": "string"}, {"type": "array", "items": {"$ref": "#/$defs/jsonValue"}}, {"type": "object", "additionalProperties": {"$ref": "#/$defs/jsonValue"}}]}
+  }
+}

evaluation/real-patch/source/code_review/contracts/real_patch_prediction_v1/validator.py

@@ -0,0 +1,179 @@
+"""Fail-closed validator for the model-visible real-patch forecast request.
+
+This module is deliberately loadable by path: the contract is not a runtime
+package and callers need not install laxmi-review to validate an input packet.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import ast
+import json
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import jsonschema
+
+
+SCHEMA_PATH = Path(__file__).with_name("forecast_request.schema.json")
+_DIFF_HEADER = re.compile(r"^diff --git a/(\S+) b/(\S+)$", re.MULTILINE)
+_TEST_PATH = re.compile(r"(?:^|/)(?:tests?|testing|fixtures?)(?:/|$)|(?:^|/)test_[^/]*\.py$|(?:^|/)[^/]*_test\.py$")
+
+
+class ForecastContractError(ValueError):
+    """The request is not safe to expose to a forecast consumer."""
+
+
+def _canonical_bytes(value: Any) -> bytes:
+    return json.dumps(
+        value, sort_keys=True, separators=(",", ":"), ensure_ascii=False, allow_nan=False
+    ).encode("utf-8")
+
+
+def input_sha256(request: dict[str, Any]) -> str:
+    """Hash the complete consumer-visible request, excluding its own hash envelope."""
+    return hashlib.sha256(
+        _canonical_bytes({key: value for key, value in request.items() if key != "shared_input"})
+    ).hexdigest()
+
+
+def source_snapshot_sha256(files: list[dict[str, Any]]) -> str:
+    """Content identity of the visible source slice, without public repository IDs."""
+    manifest = sorted(
+        ({"path": item["path"], "sha256": item["sha256"]} for item in files),
+        key=lambda item: item["path"],
+    )
+    return hashlib.sha256(_canonical_bytes(manifest)).hexdigest()
+
+
+def _instant(raw: str) -> datetime:
+    try:
+        parsed = datetime.fromisoformat(raw.replace("Z", "+00:00"))
+    except ValueError as exc:
+        raise ForecastContractError(f"invalid timestamp: {raw!r}") from exc
+    if parsed.tzinfo is None:
+        raise ForecastContractError("timestamps must include a timezone")
+    return parsed.astimezone(timezone.utc)
+
+
+def validate_forecast_request(request: dict[str, Any]) -> None:
+    """Validate shape, hashes, chronology, patch scope, and shared-input identity.
+
+    Source authenticity and semantic answer leakage still require custody checks:
+    a self-declared timestamp or hash cannot prove an external artifact existed.
+    """
+    schema = json.loads(SCHEMA_PATH.read_text(encoding="utf-8"))
+    try:
+        jsonschema.Draft202012Validator.check_schema(schema)
+        jsonschema.Draft202012Validator(
+            schema, format_checker=jsonschema.FormatChecker()
+        ).validate(request)
+    except (jsonschema.SchemaError, jsonschema.ValidationError) as exc:
+        raise ForecastContractError(f"request schema violation: {exc.message}") from exc
+
+    source = request["pre_source"]
+    patch = request["proposed_patch"]
+    scenario = request["scenario"]
+    cutoff = _instant(request["forecast_cutoff_at"])
+    proposed = _instant(patch["proposed_at"])
+    if source["snapshot_sha256"] != patch["base_snapshot_sha256"]:
+        raise ForecastContractError("patch base snapshot must match pre_source snapshot")
+    if _instant(source["snapshot_at"]) > proposed or proposed > cutoff:
+        raise ForecastContractError("source/proposal/forecast chronology is invalid")
+    if _instant(scenario["available_at"]) >= proposed:
+        raise ForecastContractError("scenario must be available before the proposed patch")
+    if scenario["origin"] == "PROSPECTIVE_GENERATOR" and scenario["selection_policy"] != "FROZEN_BEFORE_OUTCOME":
+        raise ForecastContractError("generator selection must be frozen")
+    if request["evaluation_split"] == "ACCEPTANCE_CANDIDATE" and scenario["selection_policy"] != "FROZEN_BEFORE_OUTCOME":
+        raise ForecastContractError("retrospective selection cannot be acceptance candidate")
+    program = scenario["program"]
+    if hashlib.sha256(program.encode("utf-8")).hexdigest() != scenario["program_sha256"]:
+        raise ForecastContractError("scenario program hash mismatch")
+    try:
+        syntax = ast.parse(program)
+    except SyntaxError as exc:
+        raise ForecastContractError("scenario program is not valid Python") from exc
+    for node in ast.walk(syntax):
+        if isinstance(node, ast.Assert):
+            raise ForecastContractError("scenario program contains an assertion")
+        if isinstance(node, ast.Name) and node.id.lower().startswith("expected"):
+            raise ForecastContractError("scenario program contains an expected-value variable")
+        if isinstance(node, ast.Raise) and isinstance(node.exc, ast.Call) and isinstance(node.exc.func, ast.Name) and node.exc.func.id == "AssertionError":
+            raise ForecastContractError("scenario program raises an assertion error")
+
+    paths: set[str] = set()
+    for item in source["files"]:
+        if item["path"] in paths:
+            raise ForecastContractError("duplicate source path")
+        paths.add(item["path"])
+        if hashlib.sha256(item["content"].encode("utf-8")).hexdigest() != item["sha256"]:
+            raise ForecastContractError(f"source hash mismatch: {item['path']}")
+    if source_snapshot_sha256(source["files"]) != source["snapshot_sha256"]:
+        raise ForecastContractError("source snapshot hash mismatch")
+    dependencies = request["operating_conditions"]["dependency_sources"]
+    dependency_paths: set[str] = set()
+    for item in dependencies:
+        if item["path"] in dependency_paths:
+            raise ForecastContractError("duplicate dependency path")
+        dependency_paths.add(item["path"])
+        if hashlib.sha256(item["content"].encode("utf-8")).hexdigest() != item["sha256"]:
+            raise ForecastContractError(f"dependency hash mismatch: {item['path']}")
+    if source_snapshot_sha256(dependencies) != request["operating_conditions"]["dependency_lock_sha256"]:
+        raise ForecastContractError("dependency lock hash mismatch")
+    diff = patch["unified_diff"]
+    if hashlib.sha256(diff.encode("utf-8")).hexdigest() != patch["diff_sha256"]:
+        raise ForecastContractError("proposed diff hash mismatch")
+    changed_paths = _DIFF_HEADER.findall(diff)
+    if not diff.startswith("diff --git ") or not changed_paths:
+        raise ForecastContractError("proposed diff needs git-style file headers")
+    if len(changed_paths) != sum(line.startswith("diff --git ") for line in diff.splitlines()):
+        raise ForecastContractError("proposed diff has an unrecognized file header")
+    for before, after in changed_paths:
+        if before != after:
+            raise ForecastContractError("renames need a separately reviewed contract")
+        if _TEST_PATH.search(before):
+            raise ForecastContractError("proposed diff contains a test or fixture path")
+        if before.startswith("/") or ".." in Path(before).parts:
+            raise ForecastContractError("proposed diff path escapes repository")
+        if before not in paths:
+            raise ForecastContractError("proposed diff file absent from visible pre source")
+
+    ids: set[str] = set()
+    for event in request["history"]:
+        if event["event_id"] in ids:
+            raise ForecastContractError("duplicate history event_id")
+        ids.add(event["event_id"])
+        if event["source_snapshot_sha256"] != source["snapshot_sha256"]:
+            raise ForecastContractError("history event is not from the pinned pre source")
+        if _instant(event["observed_at"]) >= proposed:
+            raise ForecastContractError("history event must predate patch proposal")
+
+    if request["shared_input"]["input_sha256"] != input_sha256(request):
+        raise ForecastContractError("shared input hash mismatch")
+
+
+def load_forecast_request(path: Path) -> dict[str, Any]:
+    """Load strict JSON and validate before passing it to any consumer."""
+    def unique_pairs(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+        value: dict[str, Any] = {}
+        for key, item in pairs:
+            if key in value:
+                raise ForecastContractError(f"duplicate JSON key: {key}")
+            value[key] = item
+        return value
+
+    def reject_constant(value: str) -> None:
+        raise ForecastContractError(f"non-finite JSON number: {value}")
+
+    try:
+        request = json.loads(
+            path.read_text(encoding="utf-8"),
+            object_pairs_hook=unique_pairs,
+            parse_constant=reject_constant,
+        )
+    except json.JSONDecodeError as exc:
+        raise ForecastContractError(f"invalid JSON: {exc.msg}") from exc
+    validate_forecast_request(request)
+    return request

evaluation/real-patch/source/code_review/packaging/real_patch/api.py

@@ -0,0 +1,120 @@
+"""Local, development-only real-patch validation and forecast interface.
+
+The forecast path reads only the model-visible request. Oracle scoring is a
+separate explicit operation, never part of forecast().
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.util
+import json
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parent / "capsule/code_review"
+CONTRACT = ROOT / "contracts/real_patch_prediction_v1/validator.py"
+EXACT = ROOT / "scripts/run_real_patch_visible_exact_v1.py"
+GATE = ROOT / "scripts/run_real_patch_baseline_gate_v2.py"
+
+
+def _module(path: Path, name: str):
+    spec = importlib.util.spec_from_file_location(name, path)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"packaged module cannot be loaded: {name}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _sha(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def validate(request_path: Path) -> dict:
+    contract = _module(CONTRACT, "laxmi_real_patch_contract")
+    request = contract.load_forecast_request(request_path)
+    return {
+        "schema_version": "laxmi.real-patch-local-api.v1",
+        "status": "ADMITTED",
+        "case_id": request["case_id"],
+        "input_sha256": contract.input_sha256(request),
+        "request_file_sha256": _sha(request_path),
+        "evaluation_split": request["evaluation_split"],
+        "custody_verified": False,
+        "acceptance_eligible": False,
+        "executed": False,
+    }
+
+
+def forecast(request_path: Path, output_dir: Path) -> dict:
+    admitted = validate(request_path)
+    exact = _module(EXACT, "laxmi_real_patch_visible_exact")
+    gate = _module(GATE, "laxmi_real_patch_gate")
+    output_dir.mkdir(mode=0o700, parents=True, exist_ok=False)
+    prediction, execution = exact.run(request_path, output_dir / "prediction")
+    sealed = gate.seal(request_path, output_dir / "prediction/predictions.json", output_dir / "seal")
+    if prediction["input_sha256"] != admitted["input_sha256"] or sealed["input_sha256"] != admitted["input_sha256"]:
+        raise ValueError("prediction changed the admitted input identity")
+    row = prediction["comparators"]["EXACT_VISIBLE_SOURCE"]
+    return {
+        "schema_version": "laxmi.real-patch-local-api.v1",
+        "status": "PREDICTED" if row["status"] == "predicted" else "UNSUPPORTED",
+        "engine_id": "EXACT_VISIBLE_SOURCE",
+        "information_tier": "SAME_INFORMATION",
+        "case_id": admitted["case_id"],
+        "input_sha256": admitted["input_sha256"],
+        "method_sha256": row.get("method_sha256"),
+        "reason": row.get("reason"),
+        "prediction_file_sha256": _sha(output_dir / "prediction/predictions.json"),
+        "seal_file_sha256": _sha(output_dir / "seal/seal.json"),
+        "oracle_read": execution["oracle_read"],
+        "custody_verified": False,
+        "acceptance_eligible": False,
+        "development_only": True,
+    }
+
+
+def score(request_path: Path, oracle_path: Path, output_dir: Path) -> dict:
+    """Privileged local evaluation call; never invoked by forecast()."""
+    gate = _module(GATE, "laxmi_real_patch_gate")
+    receipt = gate.score(request_path, oracle_path, output_dir / "seal")
+    return {
+        "schema_version": "laxmi.real-patch-local-api.v1",
+        "status": "SCORED_DEVELOPMENT_ORACLE",
+        "case_id": receipt["case_id"],
+        "input_sha256": receipt["input_sha256"],
+        "receipt_file_sha256": _sha(output_dir / "seal/receipt.json"),
+        "same_information_scored_count": receipt["same_information_scored_count"],
+        "development_only": True,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    commands = parser.add_subparsers(dest="command", required=True)
+    validation = commands.add_parser("validate")
+    validation.add_argument("--request", type=Path, required=True)
+    prediction = commands.add_parser("forecast")
+    prediction.add_argument("--request", type=Path, required=True)
+    prediction.add_argument("--output-dir", type=Path, required=True)
+    scoring = commands.add_parser("score")
+    scoring.add_argument("--request", type=Path, required=True)
+    scoring.add_argument("--oracle", type=Path, required=True)
+    scoring.add_argument("--output-dir", type=Path, required=True)
+    args = parser.parse_args()
+    try:
+        if args.command == "validate":
+            result = validate(args.request)
+        elif args.command == "forecast":
+            result = forecast(args.request, args.output_dir)
+        else:
+            result = score(args.request, args.oracle, args.output_dir)
+    except (OSError, ValueError, RuntimeError) as exc:
+        parser.exit(2, f"Laxmi real-patch refused: {exc}\n")
+    print(json.dumps(result, sort_keys=True, allow_nan=False))
+
+
+if __name__ == "__main__":
+    main()

evaluation/real-patch/source/code_review/scripts/build_real_patch_local_package_v1.py

@@ -0,0 +1,101 @@
+"""Build a source-hash-preserving local wheel for real-patch development use."""
+
+import argparse
+import base64
+import csv
+import hashlib
+import io
+import json
+from pathlib import Path
+import zipfile
+
+
+REPO = Path(__file__).resolve().parents[2]
+VERSION = "0.1.0.dev1"
+DIST = "laxmi_real_patch"
+SOURCES = {
+    "api.py": REPO / "code_review/packaging/real_patch/api.py",
+    "LICENSE": REPO / "LICENSE",
+    "NOTICE": REPO / "NOTICE",
+    "LICENSE_SCOPE.md": REPO / "LICENSE_SCOPE.md",
+    "capsule/code_review/contracts/real_patch_prediction_v1/validator.py": REPO / "code_review/contracts/real_patch_prediction_v1/validator.py",
+    "capsule/code_review/contracts/real_patch_prediction_v1/forecast_request.schema.json": REPO / "code_review/contracts/real_patch_prediction_v1/forecast_request.schema.json",
+    "capsule/code_review/scripts/run_real_patch_visible_exact_v1.py": REPO / "code_review/scripts/run_real_patch_visible_exact_v1.py",
+    "capsule/code_review/scripts/run_real_patch_baseline_gate_v2.py": REPO / "code_review/scripts/run_real_patch_baseline_gate_v2.py",
+}
+
+
+def sha(raw: bytes) -> str:
+    return hashlib.sha256(raw).hexdigest()
+
+
+def build(output: Path) -> dict:
+    if output.exists():
+        raise FileExistsError(output)
+    payload = {name: path.read_bytes() for name, path in SOURCES.items()}
+    if any(path.is_symlink() or not path.is_file() or len(payload[name]) > 1024 * 1024 for name, path in SOURCES.items()):
+        raise ValueError("package needs bounded regular source files")
+    payload["__init__.py"] = b"from .api import validate, forecast, score\n"
+    manifest = {
+        "schema_version": "laxmi.real-patch-local-package.v1",
+        "version": VERSION,
+        "development_only": True,
+        "learned_model_included": False,
+        "files": {name: sha(raw) for name, raw in sorted(payload.items())},
+    }
+    payload["manifest.json"] = (json.dumps(manifest, sort_keys=True, indent=2) + "\n").encode()
+    entries = {f"{DIST}/{name}": raw for name, raw in payload.items()}
+    info = f"{DIST}-{VERSION}.dist-info/"
+    entries[info + "METADATA"] = (
+        "Metadata-Version: 2.1\n"
+        "Name: laxmi-real-patch\n"
+        f"Version: {VERSION}\n"
+        "Summary: Development-only real-patch forecast and evaluation interface\n"
+        "Requires-Python: >=3.12,<3.13\n"
+        "Requires-Dist: jsonschema>=4.23,<5\n"
+        "License: Apache-2.0\n"
+        "Author: Navneet Prabhakar\n\n"
+    ).encode()
+    entries[info + "WHEEL"] = b"Wheel-Version: 1.0\nGenerator: laxmi-local-package\nRoot-Is-Purelib: true\nTag: py3-none-any\n"
+    entries[info + "entry_points.txt"] = b"[console_scripts]\nlaxmi-real-patch = laxmi_real_patch.api:main\n"
+    record = io.StringIO(newline="")
+    writer = csv.writer(record, lineterminator="\n")
+    for name, raw in sorted(entries.items()):
+        encoded = base64.urlsafe_b64encode(hashlib.sha256(raw).digest()).decode().rstrip("=")
+        writer.writerow([name, f"sha256={encoded}", len(raw)])
+    writer.writerow([info + "RECORD", "", ""])
+    entries[info + "RECORD"] = record.getvalue().encode()
+    output.mkdir(parents=True, exist_ok=False)
+    wheel = output / f"{DIST}-{VERSION}-py3-none-any.whl"
+    with zipfile.ZipFile(wheel, "x", compression=zipfile.ZIP_DEFLATED) as archive:
+        for name, raw in sorted(entries.items()):
+            member = zipfile.ZipInfo(name, (1980, 1, 1, 0, 0, 0))
+            member.compress_type = zipfile.ZIP_DEFLATED
+            member.external_attr = 0o100644 << 16
+            archive.writestr(member, raw)
+    receipt = {
+        "schema_version": "laxmi.real-patch-local-build.v1",
+        "version": VERSION,
+        "wheel": wheel.name,
+        "wheel_sha256": sha(wheel.read_bytes()),
+        "wheel_bytes": wheel.stat().st_size,
+        "payload_files": manifest["files"],
+        "builder_sha256": sha(Path(__file__).read_bytes()),
+        "linux_validation_pending": True,
+        "linux_exact_execution_pending": True,
+        "public_release": False,
+    }
+    (output / "build.json").write_text(json.dumps(receipt, sort_keys=True, indent=2) + "\n", encoding="utf-8")
+    return receipt
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output-dir", type=Path, required=True)
+    args = parser.parse_args()
+    result = build(args.output_dir)
+    print(json.dumps({key: result[key] for key in ("wheel", "wheel_sha256", "wheel_bytes")}, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

evaluation/real-patch/source/code_review/scripts/run_real_patch_baseline_gate_v2.py

@@ -0,0 +1,264 @@
+"""Seal same-request baseline forecasts before scoring a development oracle.
+
+This is a protocol runner, not an implementation of any comparator. Unsupported
+comparators stay in the denominator and no source or candidate code is executed.
+"""
+
+import argparse
+import hashlib
+import importlib.util
+import json
+from pathlib import Path
+
+
+SCHEMA_VERSION = "laxmi.real-patch-baseline-gate.v2"
+PREDICTION_VERSION = "laxmi.real-patch-baseline-predictions.v2"
+ORACLE_VERSION = "laxmi.real-patch-observation-oracle.v1"
+COMPARATORS = ("EXACT_EXECUTION", "EXACT_VISIBLE_SOURCE", "STATIC_RULES", "RETRIEVAL")
+INFORMATION_TIERS = ("SAME_INFORMATION", "PRIVILEGED_CEILING")
+CONTRACT_PATH = (
+    Path(__file__).resolve().parents[1]
+    / "contracts/real_patch_prediction_v1/validator.py"
+)
+
+
+def canonical_bytes(value):
+    return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode()
+
+
+def sha256(data):
+    return hashlib.sha256(data).hexdigest()
+
+
+def read_json(path):
+    def unique_pairs(pairs):
+        value = {}
+        for key, item in pairs:
+            if key in value:
+                raise ValueError(f"duplicate JSON key: {key}")
+            value[key] = item
+        return value
+
+    def reject_constant(value):
+        raise ValueError(f"non-finite JSON number: {value}")
+
+    with path.open("rb") as handle:
+        data = handle.read()
+    return json.loads(data, object_pairs_hook=unique_pairs, parse_constant=reject_constant), sha256(data)
+
+
+def write_create_only(path, value):
+    encoded = json.dumps(value, sort_keys=True, indent=2, ensure_ascii=False).encode() + b"\n"
+    with path.open("xb") as handle:
+        handle.write(encoded)
+    return sha256(encoded)
+
+
+def load_contract():
+    if not CONTRACT_PATH.is_file():
+        raise FileNotFoundError(f"forecast request validator missing: {CONTRACT_PATH}")
+    spec = importlib.util.spec_from_file_location("real_patch_forecast_validator", CONTRACT_PATH)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def validate_observation(observation, observe, classes):
+    if not isinstance(observation, dict) or set(observation) != set(observe):
+        raise ValueError("observation fields must exactly match request target.observe")
+    if observation["observation_class"] not in classes:
+        raise ValueError("observation_class outside frozen request vocabulary")
+    for field, value in observation.items():
+        if field == "return_value_sha256" and value is not None:
+            if not isinstance(value, str) or len(value) != 64 or any(
+                char not in "0123456789abcdef" for char in value
+            ):
+                raise ValueError("return_value_sha256 must be a lowercase SHA-256 or null")
+        elif field == "exception_type" and value is not None and not isinstance(value, str):
+            raise ValueError("exception_type must be a string or null")
+        elif field == "exit_code" and value is not None and (type(value) is not int):
+            raise ValueError("exit_code must be an integer or null")
+
+
+def validate_observations(observations, target):
+    branches = target["branches"]
+    if not isinstance(observations, dict) or set(observations) != set(branches):
+        raise ValueError("observations must cover both frozen intervention branches")
+    for branch in branches:
+        validate_observation(
+            observations[branch], target["observe"], target["observation_classes"]
+        )
+
+
+def validate_predictions(predictions, request, request_hash):
+    if predictions.get("schema_version") != PREDICTION_VERSION:
+        raise ValueError("wrong prediction schema_version")
+    if predictions.get("case_id") != request["case_id"]:
+        raise ValueError("prediction case_id differs from request")
+    if predictions.get("input_sha256") != request_hash:
+        raise ValueError("prediction input_sha256 differs from frozen shared input")
+    rows = predictions.get("comparators")
+    if not isinstance(rows, dict) or set(rows) != set(COMPARATORS):
+        raise ValueError("exactly four named comparator records are required")
+    for name, row in rows.items():
+        if not isinstance(row, dict) or row.get("status") not in {"predicted", "unsupported"}:
+            raise ValueError(f"{name} requires predicted or unsupported status")
+        if row.get("information_tier") not in INFORMATION_TIERS:
+            raise ValueError(f"{name} requires an explicit information_tier")
+        if name != "EXACT_EXECUTION" and row["information_tier"] != "SAME_INFORMATION":
+            raise ValueError(f"{name} must use same information")
+        if row["status"] == "unsupported":
+            if set(row) != {"status", "reason", "information_tier"} or not isinstance(row["reason"], str) or not row["reason"].strip():
+                raise ValueError(f"{name} unsupported requires only a nonempty reason")
+        else:
+            if set(row) != {"status", "observations", "method_sha256", "information_tier"}:
+                raise ValueError(f"{name} prediction requires paired observations and method SHA")
+            method = row["method_sha256"]
+            if not isinstance(method, str) or len(method) != 64 or any(
+                char not in "0123456789abcdef" for char in method
+            ):
+                raise ValueError(f"{name} method_sha256 must be a lowercase SHA-256")
+            validate_observations(row["observations"], request["target"])
+
+
+def seal(envelope_path, predictions_path, output_dir):
+    contract = load_contract()
+    request, request_file_sha = read_json(envelope_path)
+    contract.validate_forecast_request(request)
+    request_hash = contract.input_sha256(request)
+    predictions, predictions_file_sha = read_json(predictions_path)
+    validate_predictions(predictions, request, request_hash)
+    output_dir.mkdir(mode=0o700, parents=True, exist_ok=False)
+    record = {
+        "schema_version": SCHEMA_VERSION,
+        "phase": "sealed_predictions",
+        "development_only": True,
+        "case_id": request["case_id"],
+        "input_sha256": request_hash,
+        "envelope_file_sha256": request_file_sha,
+        "prediction_file_sha256": predictions_file_sha,
+        "predictions": predictions,
+        "oracle_not_read_by_seal": True,
+        "baseline_methods_not_executed_by_runner": True,
+    }
+    seal_digest = write_create_only(output_dir / "seal.json", record)
+    write_create_only(output_dir / "seal.sha256.json", {"seal_sha256": seal_digest})
+    return record
+
+
+def score(envelope_path, oracle_path, output_dir):
+    if (output_dir / "invalidated.json").exists():
+        raise ValueError("sealed prediction was invalidated; do not score")
+    seal_path = output_dir / "seal.json"
+    frozen, seal_file_sha = read_json(seal_path)
+    seal_digest_record, _ = read_json(output_dir / "seal.sha256.json")
+    if seal_digest_record != {"seal_sha256": seal_file_sha}:
+        raise ValueError("seal bytes differ from create-only digest record")
+    if frozen.get("schema_version") != SCHEMA_VERSION or frozen.get("phase") != "sealed_predictions":
+        raise ValueError("invalid seal")
+    if (output_dir / "receipt.json").exists():
+        raise FileExistsError(output_dir / "receipt.json")
+    contract = load_contract()
+    request, request_file_sha = read_json(envelope_path)
+    contract.validate_forecast_request(request)
+    request_hash = contract.input_sha256(request)
+    if (
+        frozen.get("case_id") != request["case_id"]
+        or frozen.get("input_sha256") != request_hash
+        or frozen.get("envelope_file_sha256") != request_file_sha
+    ):
+        raise ValueError("request differs from sealed request")
+    predictions = frozen["predictions"]
+    validate_predictions(predictions, request, request_hash)
+    # Oracle access begins only after the prediction seal has passed validation.
+    oracle, oracle_file_sha = read_json(oracle_path)
+    if oracle.get("schema_version") != ORACLE_VERSION or oracle.get("case_id") != request["case_id"]:
+        raise ValueError("oracle version or case_id differs from sealed request")
+    if set(oracle) != {"schema_version", "case_id", "observations"}:
+        raise ValueError("oracle contains unexpected fields")
+    target = request["target"]
+    observe = target["observe"]
+    branches = target["branches"]
+    validate_observations(oracle["observations"], target)
+    scores = {}
+    for name in COMPARATORS:
+        row = predictions["comparators"][name]
+        if row["status"] == "unsupported":
+            scores[name] = {
+                "status": "unsupported",
+                "reason": row["reason"],
+                "information_tier": row["information_tier"],
+            }
+            continue
+        branch_field_matches = {
+            branch: {
+                field: row["observations"][branch][field]
+                == oracle["observations"][branch][field]
+                for field in observe
+            }
+            for branch in branches
+        }
+        predicted_changed = (
+            row["observations"][branches[0]] != row["observations"][branches[1]]
+        )
+        observed_changed = (
+            oracle["observations"][branches[0]] != oracle["observations"][branches[1]]
+        )
+        scores[name] = {
+            "status": "scored",
+            "information_tier": row["information_tier"],
+            "method_sha256": row["method_sha256"],
+            "branch_field_matches": branch_field_matches,
+            "both_branches_match": all(
+                all(field_matches.values()) for field_matches in branch_field_matches.values()
+            ),
+            "effect_changed_match": predicted_changed == observed_changed,
+        }
+    receipt = {
+        "schema_version": SCHEMA_VERSION,
+        "phase": "scored_development_oracle",
+        "development_only": True,
+        "case_id": request["case_id"],
+        "input_sha256": request_hash,
+        "seal_file_sha256": seal_file_sha,
+        "oracle_file_sha256": oracle_file_sha,
+        "supported_comparator_count": sum(row["status"] == "scored" for row in scores.values()),
+        "unsupported_comparator_count": sum(row["status"] == "unsupported" for row in scores.values()),
+        "same_information_scored_count": sum(
+            row["status"] == "scored" and row["information_tier"] == "SAME_INFORMATION"
+            for row in scores.values()
+        ),
+        "privileged_ceiling_scored_count": sum(
+            row["status"] == "scored" and row["information_tier"] == "PRIVILEGED_CEILING"
+            for row in scores.values()
+        ),
+        "scores": scores,
+        "prediction_methods_self_declared_not_verified_by_runner": True,
+        "baseline_methods_not_executed_by_runner": True,
+        "no_learned_value_claim": True,
+    }
+    write_create_only(output_dir / "receipt.json", receipt)
+    return receipt
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    subparsers = parser.add_subparsers(dest="phase", required=True)
+    seal_parser = subparsers.add_parser("seal")
+    seal_parser.add_argument("--envelope", type=Path, required=True)
+    seal_parser.add_argument("--predictions", type=Path, required=True)
+    seal_parser.add_argument("--output-dir", type=Path, required=True)
+    score_parser = subparsers.add_parser("score")
+    score_parser.add_argument("--envelope", type=Path, required=True)
+    score_parser.add_argument("--oracle", type=Path, required=True)
+    score_parser.add_argument("--output-dir", type=Path, required=True)
+    args = parser.parse_args()
+    if args.phase == "seal":
+        result = seal(args.envelope, args.predictions, args.output_dir)
+    else:
+        result = score(args.envelope, args.oracle, args.output_dir)
+    print(json.dumps({key: result[key] for key in ("case_id", "phase")}, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

evaluation/real-patch/source/code_review/scripts/run_real_patch_visible_exact_v1.py

@@ -0,0 +1,300 @@
+"""Same-information exact execution from one validated visible forecast request.
+
+No archive, Git repository, custody record, oracle, model, or network is read.
+The request's source, dependency, diff, and scenario bytes are materialized in
+a create-only workspace. Runtime code executes only in locked-down Docker.
+"""
+
+import argparse
+import hashlib
+import importlib.util
+import json
+from pathlib import Path, PurePosixPath
+import re
+import subprocess
+
+
+IMAGE = "python:3.12-slim"
+IMAGE_ID = "sha256:78387bc3881b8273120a12ebe6c1ab22b018ccc2c9adf565ae1ac9b536e184ea"
+PREDICTION_VERSION = "laxmi.real-patch-baseline-predictions.v2"
+CONTRACT_PATH = Path(__file__).resolve().parents[1] / "contracts/real_patch_prediction_v1/validator.py"
+HUNK = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@")
+HEADER = re.compile(r"^diff --git a/(\S+) b/(\S+)\n$")
+
+
+class UnsupportedVisibleExecution(ValueError):
+    """The visible request cannot supply a valid runnable source slice."""
+
+
+def digest(data):
+    return hashlib.sha256(data).hexdigest()
+
+
+def canonical_bytes(value):
+    return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode()
+
+
+def write_create_only(path, data):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("xb") as handle:
+        handle.write(data)
+
+
+def safe_path(root, relative):
+    path = PurePosixPath(relative)
+    if path.is_absolute() or ".." in path.parts or not path.parts:
+        raise UnsupportedVisibleExecution("patch path escapes visible workspace")
+    return root.joinpath(*path.parts)
+
+
+def apply_file_hunks(source, hunk_lines):
+    original = source.splitlines(keepends=True)
+    output = []
+    cursor = 0
+    index = 0
+    while index < len(hunk_lines):
+        match = HUNK.match(hunk_lines[index])
+        if match is None:
+            raise UnsupportedVisibleExecution("patch has content outside a hunk")
+        old_start = int(match.group(1))
+        old_count = int(match.group(2) or "1")
+        new_start = int(match.group(3))
+        new_count = int(match.group(4) or "1")
+        start = old_start - 1 if old_count else old_start
+        if start < cursor or start > len(original):
+            raise UnsupportedVisibleExecution("overlapping or out-of-range patch hunk")
+        output.extend(original[cursor:start])
+        expected_new_start = len(output) + 1 if new_count else len(output)
+        if new_start != expected_new_start:
+            raise UnsupportedVisibleExecution("patch destination hunk position is inconsistent")
+        position = start
+        old_seen = 0
+        new_seen = 0
+        index += 1
+        while index < len(hunk_lines) and not hunk_lines[index].startswith("@@ "):
+            line = hunk_lines[index]
+            if not line or line[0] not in " +-" or not line.endswith("\n"):
+                raise UnsupportedVisibleExecution("unsupported patch line")
+            text = line[1:]
+            if line[0] in " -":
+                if position >= len(original) or original[position] != text:
+                    raise UnsupportedVisibleExecution("patch context differs from visible source")
+                position += 1
+                old_seen += 1
+            if line[0] in " +":
+                output.append(text)
+                new_seen += 1
+            index += 1
+        if old_seen != old_count or new_seen != new_count:
+            raise UnsupportedVisibleExecution("patch hunk line counts are inconsistent")
+        cursor = position
+    output.extend(original[cursor:])
+    return "".join(output)
+
+
+def apply_visible_diff(pre_root, post_root, diff, source_paths):
+    lines = diff.splitlines(keepends=True)
+    index = 0
+    changed = []
+    while index < len(lines):
+        match = HEADER.match(lines[index])
+        if match is None or match.group(1) != match.group(2):
+            raise UnsupportedVisibleExecution("only same-path git-style text diffs are supported")
+        path = match.group(1)
+        if path not in source_paths or path in changed:
+            raise UnsupportedVisibleExecution("patch file absent from visible source or repeated")
+        changed.append(path)
+        index += 1
+        if index + 1 >= len(lines) or lines[index] != f"--- a/{path}\n" or lines[index + 1] != f"+++ b/{path}\n":
+            raise UnsupportedVisibleExecution("patch file headers are inconsistent")
+        index += 2
+        hunks = []
+        while index < len(lines) and not lines[index].startswith("diff --git "):
+            hunks.append(lines[index])
+            index += 1
+        if not hunks:
+            raise UnsupportedVisibleExecution("patch file has no hunks")
+        before = safe_path(pre_root, path).read_text(encoding="utf-8")
+        after = apply_file_hunks(before, hunks)
+        safe_path(post_root, path).write_text(after, encoding="utf-8")
+    if not changed:
+        raise UnsupportedVisibleExecution("visible diff has no patch files")
+    return changed
+
+
+def load_contract():
+    spec = importlib.util.spec_from_file_location("real_patch_forecast_validator", CONTRACT_PATH)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def check_image():
+    result = subprocess.run(
+        ["docker", "image", "inspect", IMAGE, "--format", "{{.Id}}"],
+        capture_output=True, text=True, check=True, timeout=20,
+    )
+    if result.stdout.strip() != IMAGE_ID:
+        raise ValueError("Docker image ID differs from pinned runtime")
+
+
+def observation(completed, observe):
+    if completed.returncode == 0:
+        try:
+            payload = json.loads(completed.stdout)
+        except json.JSONDecodeError as exc:
+            raise UnsupportedVisibleExecution("visible program did not emit one JSON result") from exc
+        if not isinstance(payload, dict) or set(payload) != {"may", "actual"} or any(
+            type(value) is not bool for value in payload.values()
+        ):
+            raise UnsupportedVisibleExecution("visible program result must be raw may/actual booleans")
+        values = {
+            "observation_class": "RETURN",
+            "return_value_sha256": digest(canonical_bytes(payload)),
+            "exception_type": None,
+            "exit_code": 0,
+        }
+    elif "ModuleNotFoundError" in completed.stderr or "ImportError" in completed.stderr:
+        raise UnsupportedVisibleExecution("visible source/dependency slice cannot import")
+    else:
+        values = {
+            "observation_class": "PROCESS_ERROR",
+            "return_value_sha256": None,
+            "exception_type": None,
+            "exit_code": completed.returncode,
+        }
+    return {field: values[field] for field in observe}
+
+
+def run_branch(program_path, source_root, deps_root, timeout_seconds, observe):
+    command = [
+        "docker", "run", "--rm", "--pull", "never", "--network", "none",
+        "--read-only", "--cap-drop", "ALL", "--security-opt", "no-new-privileges",
+        "--pids-limit", "64", "--memory", "256m", "--cpus", "1",
+        "--user", "65534:65534",
+        "--mount", f"type=bind,source={program_path.resolve()},target=/scenario.py,readonly",
+        "--mount", f"type=bind,source={source_root.resolve()},target=/src,readonly",
+        "--mount", f"type=bind,source={deps_root.resolve()},target=/deps,readonly",
+        "--env", "PYTHONPATH=/src:/deps", "--env", "PYTHONDONTWRITEBYTECODE=1",
+        IMAGE, "python", "/scenario.py",
+    ]
+    try:
+        result = subprocess.run(
+            command, capture_output=True, text=True, check=False, timeout=timeout_seconds,
+        )
+    except subprocess.TimeoutExpired:
+        values = {"observation_class": "TIMEOUT", "return_value_sha256": None,
+                  "exception_type": None, "exit_code": None}
+        return {field: values[field] for field in observe}, {"command": command, "timed_out": True}
+    if result.returncode == 125:
+        raise RuntimeError(f"Docker setup failed: {result.stderr[-1000:]}")
+    return observation(result, observe), {
+        "command": command,
+        "exit_code": result.returncode,
+        "stdout": result.stdout,
+        "stderr": result.stderr,
+        "stdout_sha256": digest(result.stdout.encode()),
+        "stderr_sha256": digest(result.stderr.encode()),
+    }
+
+
+def run(request_path, output_dir):
+    contract = load_contract()
+    request = contract.load_forecast_request(request_path)
+    if request["target"]["branches"] != ["NO_CHANGE", "PROPOSED_PATCH"]:
+        raise ValueError("paired branch order required")
+    observe = request["target"]["observe"]
+    if "observation_class" not in observe or "return_value_sha256" not in observe:
+        raise ValueError("raw paired result fields required")
+    output_dir.mkdir(mode=0o700, parents=True, exist_ok=False)
+    workspace = output_dir / "workspace"
+    pre_root = workspace / "no_change"
+    post_root = workspace / "proposed_patch"
+    deps_root = workspace / "deps"
+    source_paths = set()
+    for item in request["pre_source"]["files"]:
+        source_paths.add(item["path"])
+        for root in (pre_root, post_root):
+            write_create_only(safe_path(root, item["path"]), item["content"].encode())
+    for item in request["operating_conditions"]["dependency_sources"]:
+        relative = item["path"]
+        if not relative.startswith("deps/"):
+            raise ValueError("dependency path must be under deps/")
+        write_create_only(safe_path(workspace, relative), item["content"].encode())
+    program_path = workspace / "scenario.py"
+    write_create_only(program_path, request["scenario"]["program"].encode())
+    method = {
+        "script_sha256": digest(Path(__file__).read_bytes()),
+        "image_id": IMAGE_ID,
+        "input_sha256": contract.input_sha256(request),
+        "visible_source_snapshot_sha256": request["pre_source"]["snapshot_sha256"],
+        "visible_diff_sha256": request["proposed_patch"]["diff_sha256"],
+        "visible_dependency_lock_sha256": request["operating_conditions"]["dependency_lock_sha256"],
+        "visible_program_sha256": request["scenario"]["program_sha256"],
+    }
+    runs = {}
+    changed = []
+    try:
+        changed = apply_visible_diff(
+            pre_root, post_root, request["proposed_patch"]["unified_diff"], source_paths
+        )
+        check_image()
+        observations = {}
+        for branch, root in (("NO_CHANGE", pre_root), ("PROPOSED_PATCH", post_root)):
+            observations[branch], runs[branch] = run_branch(
+                program_path, root, deps_root,
+                request["target"]["horizon"]["max_seconds"], observe,
+            )
+        exact = {
+            "status": "predicted",
+            "information_tier": "SAME_INFORMATION",
+            "observations": observations,
+            "method_sha256": digest(canonical_bytes(method)),
+        }
+    except UnsupportedVisibleExecution as exc:
+        exact = {
+            "status": "unsupported",
+            "information_tier": "SAME_INFORMATION",
+            "reason": str(exc),
+        }
+    def unsupported(reason, tier):
+        return {"status": "unsupported", "information_tier": tier, "reason": reason}
+    prediction = {
+        "schema_version": PREDICTION_VERSION,
+        "case_id": request["case_id"],
+        "input_sha256": contract.input_sha256(request),
+        "comparators": {
+            "EXACT_EXECUTION": unsupported("Privileged full-source ceiling is separate", "PRIVILEGED_CEILING"),
+            "EXACT_VISIBLE_SOURCE": exact,
+            "STATIC_RULES": unsupported("No static comparator sealed for this case", "SAME_INFORMATION"),
+            "RETRIEVAL": unsupported("No pre-cutoff retrieval index sealed for this case", "SAME_INFORMATION"),
+        },
+    }
+    receipt = {
+        "schema_version": "laxmi.real-patch-visible-exact.v1",
+        "development_only": True,
+        "oracle_read": False,
+        "custody_or_post_archive_read": False,
+        "input_sha256": contract.input_sha256(request),
+        "method": method,
+        "changed_visible_paths": changed,
+        "runs": runs,
+        "status": exact["status"],
+    }
+    for name, value in (("predictions.json", prediction), ("execution.json", receipt)):
+        write_create_only(output_dir / name, json.dumps(value, sort_keys=True, indent=2).encode() + b"\n")
+    return prediction, receipt
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--request", type=Path, required=True)
+    parser.add_argument("--output-dir", type=Path, required=True)
+    args = parser.parse_args()
+    prediction, _ = run(args.request, args.output_dir)
+    print(json.dumps({"case_id": prediction["case_id"],
+                      "status": prediction["comparators"]["EXACT_VISIBLE_SOURCE"]["status"]}, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

release.json

@@ -2,33 +2,46 @@
   "author": "Navneet Prabhakar",
   "candidates": {
     "17-normalized": {
-      "metadata_sha256": "225a71bb67d619e70f1aec0313d2c5791d0a94ac3942297ad12ba284269cddd8",
-      "example_forecast_sha256": "e4c9661abcc03fe8aee0ae5bf57e1b12f9e8a56becc67e41d26ea106b0ae5267"
+      "example_forecast_sha256": "e4c9661abcc03fe8aee0ae5bf57e1b12f9e8a56becc67e41d26ea106b0ae5267",
+      "metadata_sha256": "225a71bb67d619e70f1aec0313d2c5791d0a94ac3942297ad12ba284269cddd8"
     },
     "17-original": {
-      "metadata_sha256": "a958ceb64e802decf331d10e98ddfcdc042658834469a0cc4a131e44134de906",
-      "example_forecast_sha256": "5cca70b946ccaac1a453f899fc54e088452728a24ae9e6ba7f5f2e8ee5b6e6e6"
+      "example_forecast_sha256": "5cca70b946ccaac1a453f899fc54e088452728a24ae9e6ba7f5f2e8ee5b6e6e6",
+      "metadata_sha256": "a958ceb64e802decf331d10e98ddfcdc042658834469a0cc4a131e44134de906"
     },
     "43-normalized": {
-      "metadata_sha256": "8eb622127bb5a9d739967855b8d7d8b7290395d7ae3a83315325b1a20869146f",
-      "example_forecast_sha256": "cbe28210ab8bce43ebe5223b38c62fdcd07cf796d26173651da03fd32c2135e8"
+      "example_forecast_sha256": "cbe28210ab8bce43ebe5223b38c62fdcd07cf796d26173651da03fd32c2135e8",
+      "metadata_sha256": "8eb622127bb5a9d739967855b8d7d8b7290395d7ae3a83315325b1a20869146f"
     },
     "43-original": {
-      "metadata_sha256": "4e02bd6724288e074fb30f04164a83559eff5e370e94bc473ace3ac22bc7a742",
-      "example_forecast_sha256": "c18c7cbb05b59973026e370a6ba8bfb2e35f1e9d772ff183a32dec94da6ccc93"
+      "example_forecast_sha256": "c18c7cbb05b59973026e370a6ba8bfb2e35f1e9d772ff183a32dec94da6ccc93",
+      "metadata_sha256": "4e02bd6724288e074fb30f04164a83559eff5e370e94bc473ace3ac22bc7a742"
     }
   },
   "clean_install_verified": true,
   "dependency_hash_lock": false,
+  "distribution_scope": "RELEASE_SCOPE.md; exact files enumerated by SHA256SUMS",
   "license": "Apache-2.0",
   "model_acceptance": false,
   "original_wheel_sha256": "e1bafeb8d72e231a3029cf11ffabb8e54aa28e1b953040e81e77cf1fa3ac270d",
   "package_sha256": "a74db8e3196267387e3a4cfb55b838d112a86c88adac031f6515b88230a29fcc",
+  "real_patch_tool": {
+    "blind_acceptance_cases": 0,
+    "exposed_development_cases": 6,
+    "hosted_api": false,
+    "kind": "local_exact_execution_baseline",
+    "learned_real_patch_weights": false,
+    "linux_exact_execution_qualified": false,
+    "oracle_only_cases": 5,
+    "scored_forecast_cases": 1,
+    "source_commit": "63cbecbad1bd8832d9c4fae65e4cfad27c57fa76",
+    "wheel": "evaluation/real-patch/runtime/laxmi_real_patch-0.1.0.dev1-py3-none-any.whl",
+    "wheel_sha256": "a36e136b730b9b941af303ca23dcdaaff0268b3e3dfafab4122730ee45d8da0e"
+  },
+  "repository_checkpoint_commit": "4dae1a041be532d663f477effe9b654b428bc04e",
   "runtime_sources": 133,
   "schema_version": "laxmi.experimental-public-package.v1",
+  "source_identity_basis": "original runtime wheel SHA256 and per-file checkpoint source locks; repository checkpoint is a recovery anchor, not a claim of identical historical source tree",
   "supported_platform": "macOS ARM64, Python 3.12; other platforms unverified",
-  "version": "0.1.0",
-  "distribution_scope": "RELEASE_SCOPE.md; exact files enumerated by SHA256SUMS",
-  "repository_checkpoint_commit": "4dae1a041be532d663f477effe9b654b428bc04e",
-  "source_identity_basis": "original runtime wheel SHA256 and per-file checkpoint source locks; repository checkpoint is a recovery anchor, not a claim of identical historical source tree"
+  "version": "0.1.1"
 }