Add AWS CardDemo no-cost modernization proof

Reproducible no-cost modernization proof bundle. Static/source-oracle parity is B=50/F=0/gaps=0 under the current rubric. This does not claim live COBOL/CICS all-path runtime equivalence; paid/licensed legacy runtime validation remains outside the no-cost path.

DUE_DILIGENCE.md

@@ -0,0 +1,33 @@
+# Basic Due Diligence
+
+Clone this HF repository and inspect:
+
+1. `README.md`
+2. `final_proof/FINAL_PROOF_README.md`
+3. `final_proof/NO_COST_CONFIDENCE_README.md`
+4. `final_proof/A_GRADE_PROMOTION_README.md`
+
+Then clone the upstream AWS source next to `modern_code`:
+
+```powershell
+git clone https://github.com/aws-samples/aws-mainframe-modernization-carddemo.git source
+git -C source checkout 59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e
+```
+
+From `modern_code`, run:
+
+```powershell
+python -m unittest discover -s tests
+python tools\replay_static_oracles.py --source-root ..\source --out-dir .\reports --source-head 59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e
+python tools\build_no_cost_confidence.py --source-root ..\source --out-dir .\final_proof
+python tools\evaluate_a_grade_promotion.py --source-root ..\source --out-dir .\final_proof
+```
+
+Expected high-level result:
+
+- tests pass,
+- static replay returns `"passed": true`,
+- no-cost confidence returns `"reviewer_posture": "strong_pre_runtime_confidence"`,
+- A-grade gate returns `"promotable_to_A": false`.
+
+That last result is intentional: `cjc0013/aws-carddemo-no-cost-modernization-proof` does not claim live COBOL/CICS runtime parity.

HF_PUBLICATION_MANIFEST.json

@@ -0,0 +1,235 @@
+{
+  "bundle_version": "carddemo_hf_public_bundle_v0",
+  "claim_boundary": "No live COBOL/CICS all-path runtime equivalence is claimed.",
+  "files": [
+    {
+      "path": "DUE_DILIGENCE.md",
+      "sha256": "ba1761daf4641891cbb3c019715104dde6e86d766fb1a29f926158e5a6186eae",
+      "size_bytes": 1223
+    },
+    {
+      "path": "final_proof/A_GRADE_PROMOTION_README.md",
+      "sha256": "5f2f3ea1974e43f1defa62831a6d79d1c4f2e66700fe1d5f6dc152514ce33939",
+      "size_bytes": 1489
+    },
+    {
+      "path": "final_proof/A_GRADE_PROMOTION_REPORT.json",
+      "sha256": "8ad18619c8e593c0f0e1d17864fa52a9882f9829feb27ac00560545fbdd6049a",
+      "size_bytes": 28860
+    },
+    {
+      "path": "final_proof/ARTIFACT_MANIFEST.json",
+      "sha256": "786f290fe46f735840da5622692ba2097c2c88fb14ec5238291f64d421ce013f",
+      "size_bytes": 7662
+    },
+    {
+      "path": "final_proof/CLEAN_REPRO_VERIFICATION.json",
+      "sha256": "5adda5d20e306a2c4d5cdcc316d669a99cb8d63043c055362862d43fb06f6d02",
+      "size_bytes": 15468
+    },
+    {
+      "path": "final_proof/FINAL_PROOF_README.md",
+      "sha256": "9dc65f1351b5891211a2762c76e33c3888f6d4e05e1f5dc33df0954e53d84da6",
+      "size_bytes": 5534
+    },
+    {
+      "path": "final_proof/FINAL_RECEIPT_SUMMARY.json",
+      "sha256": "e7a72987c737f87cd8ede33de7206349952a3ecc1a6c7f547d383c9c19abeee1",
+      "size_bytes": 25158
+    },
+    {
+      "path": "final_proof/KNOWN_LIMITS.md",
+      "sha256": "529ec1c050d1ada363dfc1bfce17d1be823b7f282a915678e7b895346da5efd4",
+      "size_bytes": 1306
+    },
+    {
+      "path": "final_proof/NO_COST_CONFIDENCE_README.md",
+      "sha256": "0da33294abcda04a421a4bb27ea02cd2d656983c6c75f28adc04ecb1b41bbab0",
+      "size_bytes": 1561
+    },
+    {
+      "path": "final_proof/NO_COST_CONFIDENCE_REPORT.json",
+      "sha256": "081061a5b5bdda980854336936b03218f083a150cc1120311da3364fb764a7d8",
+      "size_bytes": 28924
+    },
+    {
+      "path": "final_proof/REPRO_COMMANDS.txt",
+      "sha256": "975ba3c0ebdb7c5dd248e75ee4c03a5dd0ca832cf32e8917da920afa8667f363",
+      "size_bytes": 2043
+    },
+    {
+      "path": "final_proof/STATIC_ORACLE_REPLAY_REPORT.json",
+      "sha256": "55f09392a6a1166990c6349959fba676149e7d761bc1579c60636e8e2970a5a8",
+      "size_bytes": 18230
+    },
+    {
+      "path": "HF_PUBLICATION_MANIFEST.json",
+      "sha256": "baf84de3db93763c53c55b74c6baae728905ca4e79aab34a6fab46a99236b2a0",
+      "size_bytes": 8258
+    },
+    {
+      "path": "METHODOLOGY.md",
+      "sha256": "91f46037b3a525bd2284a0d7469156112054e2d32a8cb6a3e4f0c4445373f52b",
+      "size_bytes": 1526
+    },
+    {
+      "path": "modern_code/carddemo/__init__.py",
+      "sha256": "88e21b7382dd9fe71363fda8b550e14579b7b6efa15941a4fff87b2129d03edc",
+      "size_bytes": 55
+    },
+    {
+      "path": "modern_code/carddemo/api.py",
+      "sha256": "c9c66bc488f2e9cbb7c2b91cdd7a18feea97e8d65e9fce2590d7a05780ef65e6",
+      "size_bytes": 17553
+    },
+    {
+      "path": "modern_code/carddemo/cli.py",
+      "sha256": "28653d1b7f7797d31cdd2d57405807542c2b708822ec0d8fe58d6f728706f18e",
+      "size_bytes": 1443
+    },
+    {
+      "path": "modern_code/carddemo/legacy_parser.py",
+      "sha256": "fcf1123c214e8fd373ef6f80d0c318c295f90b3d971f217975962d2b0878385b",
+      "size_bytes": 12511
+    },
+    {
+      "path": "modern_code/carddemo/parity.py",
+      "sha256": "e749277f5f900a44b0a50c1208baa3f1b73016f5037653cb8288d2f9c572e527",
+      "size_bytes": 98504
+    },
+    {
+      "path": "modern_code/carddemo/repository.py",
+      "sha256": "bcb4198d782f88fdf41b07fde8bc3502e49de1d6bf2341bfa6c66d41f469b106",
+      "size_bytes": 11744
+    },
+    {
+      "path": "modern_code/carddemo/service.py",
+      "sha256": "f7ba4759d188c41e55ce2239e392f19409f1118c2aff4535dd29da3ed3b5d46e",
+      "size_bytes": 146360
+    },
+    {
+      "path": "modern_code/README.md",
+      "sha256": "373916dcb6ff772687cb824e26553529c971ddaa88531c55580e64a83f56484a",
+      "size_bytes": 8553
+    },
+    {
+      "path": "modern_code/static/app.js",
+      "sha256": "1322d5918649e8c57f714c6d6e4a7fff5cf0e83024ae2beae9534514158531bf",
+      "size_bytes": 20295
+    },
+    {
+      "path": "modern_code/static/index.html",
+      "sha256": "004cc27d08bb4ebe4dd78d0895fa97cb3bd97c987b426f95b17af245960ee322",
+      "size_bytes": 3386
+    },
+    {
+      "path": "modern_code/static/styles.css",
+      "sha256": "c416c17a163b560a88d2a816dd68701826ed9b21617ee3166205ec721f4fbd4b",
+      "size_bytes": 3822
+    },
+    {
+      "path": "modern_code/tests/test_a_grade_promotion.py",
+      "sha256": "ce335d767c4492cc8c78f7123aafa238afa97173938afca77c8641614a240dfb",
+      "size_bytes": 4022
+    },
+    {
+      "path": "modern_code/tests/test_hf_public_bundle.py",
+      "sha256": "53c0798a41d36b0df9ff29ed2c63a445b5a3152b2bcd1c290c4f657f66f95b1e",
+      "size_bytes": 3865
+    },
+    {
+      "path": "modern_code/tests/test_legacy_parser.py",
+      "sha256": "c0c949f0793328fe01bd7d0304f15507a59d3b3573400249f7c753be95d99379",
+      "size_bytes": 2935
+    },
+    {
+      "path": "modern_code/tests/test_no_cost_confidence.py",
+      "sha256": "ff1ab81e962269bb72f953929722857937fb6aed48ada518c33f767e76279551",
+      "size_bytes": 3542
+    },
+    {
+      "path": "modern_code/tests/test_parity.py",
+      "sha256": "a313fcddfd58a7790b30a8b601196dada407a043515f59399db0ac1e86d4815a",
+      "size_bytes": 12652
+    },
+    {
+      "path": "modern_code/tests/test_service.py",
+      "sha256": "b5c16936a031ad435a622bc1b00f4c7c4074e8bf5bbbeb7fc09e1e42090261f2",
+      "size_bytes": 40006
+    },
+    {
+      "path": "modern_code/tests/test_static_oracle_replay.py",
+      "sha256": "1c399d1ec36bc5f34c3379f4374df03e7a040da4636b0ee9db0cb90ece99a8aa",
+      "size_bytes": 2245
+    },
+    {
+      "path": "modern_code/tools/build_hf_public_bundle.py",
+      "sha256": "b4fa079c50b33f1a4b4ea497a37581e0e0e19fc7ffd42af7f4d54d2681b4aa47",
+      "size_bytes": 16171
+    },
+    {
+      "path": "modern_code/tools/build_no_cost_confidence.py",
+      "sha256": "1e9b63e25971041174c094e80f76fd8a84823dd2c5b5216dd3c40b787e000406",
+      "size_bytes": 20629
+    },
+    {
+      "path": "modern_code/tools/evaluate_a_grade_promotion.py",
+      "sha256": "fed8e1c221d0078971c2b692ce3ba04ade0ac6682203e68cc3a41292a069a3ca",
+      "size_bytes": 21030
+    },
+    {
+      "path": "modern_code/tools/generate_receipts.py",
+      "sha256": "ae376f9fbb319314e12d2ac59e8c59cb7bf65898c4b53db8edb536c92aeab6e1",
+      "size_bytes": 7332
+    },
+    {
+      "path": "modern_code/tools/package_final_proof.py",
+      "sha256": "d5595e8f8fa0da9d4d06f6b56a3100cecb9bd038620b56dd2f5090556f6f389b",
+      "size_bytes": 25482
+    },
+    {
+      "path": "modern_code/tools/replay_static_oracles.py",
+      "sha256": "be50faa32dfb4d9c1eb685f389e8976f481c3c761a71c99a31c22144a75f931b",
+      "size_bytes": 15393
+    },
+    {
+      "path": "modern_code/tools/verify_clean_repro.py",
+      "sha256": "27dea778fd820e427678ae24ff22b74d369a9ece5901e36f83394a3fd516481c",
+      "size_bytes": 10249
+    },
+    {
+      "path": "PUBLICATION_NOTES.md",
+      "sha256": "338803c95bda8a098211dca8008b363890ea57ba099eb8689f9e95f4f9c4e3ba",
+      "size_bytes": 520
+    },
+    {
+      "path": "README.md",
+      "sha256": "e16aac36654e08b761c308a0673deae0a1c057c33b213be1f389366aa3d8aac1",
+      "size_bytes": 3762
+    },
+    {
+      "path": "REPRODUCIBILITY.md",
+      "sha256": "e4f570ed3618fe4e87240fc7734ff82458deddead341de87e5432295dd8f95c2",
+      "size_bytes": 1126
+    }
+  ],
+  "generated_utc": "2026-05-23T15:02:36+00:00",
+  "hf_repo_id": "cjc0013/aws-carddemo-no-cost-modernization-proof",
+  "manifest_hash": "d58f22794bbd4eeec620cedf766e6f312a8702a8c56209c38a7ae8122e7d7441",
+  "modern_snapshot_file_count": 25,
+  "proof_file_count": 11,
+  "proof_summary": {
+    "B": 50,
+    "F": 0,
+    "a_promotable": false,
+    "gaps": 0,
+    "no_cost_reviewer_posture": "strong_pre_runtime_confidence"
+  },
+  "public_safe_checks": {
+    "live_runtime_equivalence_claim_made": false,
+    "original_source_tree_copied": false,
+    "paid_runtime_claim_made": false
+  },
+  "source_head": "59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e",
+  "source_repo": "https://github.com/aws-samples/aws-mainframe-modernization-carddemo.git"
+}

METHODOLOGY.md

@@ -0,0 +1,33 @@
+# Methodology
+
+## Goal
+
+Produce the strongest practical modernization proof possible without paid or licensed legacy runtime infrastructure.
+
+## Method
+
+1. Pin the upstream AWS CardDemo source repository and commit.
+2. Hash the source files and generated modern files.
+3. Extract capabilities from legacy source, copybooks, BMS maps, JCL, seed data, and static contracts.
+4. Build a one-for-one capability ledger.
+5. Implement the modern Python/SQLite target against those source-derived contracts.
+6. Generate receipts, golden traces, edge cases, and parity reports.
+7. Execute the modern service against static/source-oracle replay checks.
+8. Run clean-copy reproduction and API smoke checks.
+9. Run a strict A-grade gate that refuses promotion without live legacy runtime traces.
+10. Publish the evidence with explicit boundaries.
+
+## Current Proof State
+
+- B-grade static/source-oracle capabilities: `50`
+- F-grade gaps: `0`
+- Gap count: `0`
+- Static replay passed: `True`
+- No-cost confidence posture: `strong_pre_runtime_confidence`
+- A-grade promotable: `False`
+
+## What Would Upgrade This To A
+
+The A-grade gate requires accepted live legacy runtime trace records for every capability. Each record must bind a capability ID to the pinned source head, a live runtime trace kind, a raw legacy trace hash, a modern observation hash, a comparator version, and `matched=true`.
+
+The current bundle has zero accepted live runtime matches because no paid/licensed legacy runtime was executed.

PUBLICATION_NOTES.md

@@ -0,0 +1,8 @@
+# Publication Notes
+
+- This is a proof artifact, not a production migration recommendation.
+- The original AWS CardDemo source tree is not redistributed here.
+- The modern code snapshot is provided for review of the local modernization artifact.
+- The proof explicitly avoids claiming live COBOL/CICS equivalence.
+- The phrase "strong pre-runtime confidence" means the no-cost checks passed; it does not mean production acceptance.
+- Further proof requires paid/licensed or customer-owned legacy runtime access.

README.md

@@ -0,0 +1,86 @@
+---
+license: other
+language:
+- en
+tags:
+- mainframe-modernization
+- cobol
+- cics
+- static-analysis
+- verification
+- reproducibility
+- legacy-modernization
+pretty_name: AWS CardDemo No-Cost Modernization Proof
+---
+
+# AWS CardDemo No-Cost Modernization Proof
+
+This repository publishes a reproducible proof bundle for a local modernization run against AWS CardDemo. It is intentionally **not** a claim of live COBOL/CICS all-path runtime equivalence.
+
+Plainly: this is not a claim of live COBOL/CICS all-path runtime equivalence.
+
+The practical claim is narrower and receipt-backed: we pushed the free/no-cost verification path as far as we reasonably could. The remaining validation requires a real or licensed-compatible legacy runtime for COBOL/CICS/VSAM/JCL execution.
+
+In short: without paid/licensed legacy runtime access, this is as far as this proof can honestly go.
+
+## Headline Result
+
+- Reviewer posture: `strong_pre_runtime_confidence`
+- Ready for pre-runtime review: `True`
+- Current static/source-oracle parity: `B=50 / F=0 / gaps=0`
+- A-grade live runtime parity: `A=0`
+- A-grade promotion gate: `do_not_promote`
+- A-grade live matches accepted: `0`
+- A-grade live matches missing: `50`
+- Paid runtime used: `False`
+- Legacy runtime equivalence claimed: `False`
+
+## Source Identity
+
+- Upstream source repo: `https://github.com/aws-samples/aws-mainframe-modernization-carddemo.git`
+- Upstream source commit: `59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e`
+- Source files hashed in receipt: `204`
+- Source hash digest: `0703f97553bde0f5bd170aa95ec8c771a975b397be7d9e8088ec6fbf31d333c2`
+
+The upstream AWS CardDemo source tree is **not copied into this repository**. Clone it from the upstream project at the exact commit above when reproducing.
+
+## Evidence Included
+
+- `final_proof/FINAL_PROOF_README.md`: technical reviewer entry point.
+- `final_proof/FINAL_RECEIPT_SUMMARY.json`: machine-readable receipt summary.
+- `final_proof/NO_COST_CONFIDENCE_REPORT.json`: no-cost confidence evidence and methodology.
+- `final_proof/A_GRADE_PROMOTION_REPORT.json`: strict A-grade gate and why it does not promote without live traces.
+- `final_proof/STATIC_ORACLE_REPLAY_REPORT.json`: executable modern replay over static/source-derived oracles.
+- `METHODOLOGY.md`: evidence method and proof boundaries.
+- `REPRODUCIBILITY.md`: one-command local checks.
+- `DUE_DILIGENCE.md`: quick reviewer checklist.
+- `modern_code/`: modern Python/SQLite implementation snapshot and proof tooling.
+
+## No-Cost Evidence Summary
+
+- Capability count: `50`
+- Static/source-oracle-ready capabilities: `50`
+- Capability source references: `101`
+- Golden traces: `34`
+- Edge cases: `40`
+- COBOL programs scanned: `44`
+- CICS programs identified: `25`
+- Free GnuCOBOL probe candidates: `17`
+
+## The Unpaid Boundary
+
+We cannot honestly push this to live runtime parity without access to a real or licensed-compatible legacy execution environment. That means one of:
+
+- AWS Mainframe Modernization runtime access,
+- Micro Focus / Enterprise Server-style runtime access,
+- UniKix or equivalent runtime access,
+- a real z/OS/CICS/VSAM/JCL endpoint,
+- or another compatible environment capable of executing the original legacy paths.
+
+Without that, the correct remaining statement is: the modernization is strongly supported by source-derived static oracles and executable modern replay, but final production-equivalence validation must happen on the legacy runtime owner’s environment.
+
+## Repository Type
+
+This is published as a Hugging Face dataset-style proof artifact, not a trained model and not a hosted runtime.
+
+HF repo target used for staging: `cjc0013/aws-carddemo-no-cost-modernization-proof`

REPRODUCIBILITY.md

@@ -0,0 +1,16 @@
+# Reproducibility
+
+This bundle is reproducible with no paid legacy runtime, but it still requires cloning the upstream AWS source at the pinned commit.
+
+```powershell
+git clone https://github.com/aws-samples/aws-mainframe-modernization-carddemo.git source
+git -C source checkout 59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e
+cd modern_code
+powershell -NoProfile -Command "python -m carddemo.cli init-db --source-root ..\source --db-path .\carddemo.sqlite; python -m unittest discover -s tests; python tools\generate_receipts.py --source-root ..\source --db-path .\carddemo.sqlite --out-dir .\reports; python tools\replay_static_oracles.py --source-root ..\source --out-dir .\reports --source-head 59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e; python tools\evaluate_a_grade_promotion.py --source-root ..\source --out-dir .\final_proof; python tools\build_no_cost_confidence.py --source-root ..\source --out-dir .\final_proof; python tools\package_final_proof.py --source-root ..\source"
+```
+
+For clean-copy reproduction, run:
+
+```powershell
+python tools\verify_clean_repro.py --modern-root . --source-root ..\source
+```

final_proof/ARTIFACT_MANIFEST.json

@@ -0,0 +1,155 @@
+{
+  "bundle_files": [
+    {
+      "absolute_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\final_proof\\FINAL_PROOF_README.md",
+      "exists": true,
+      "path": "FINAL_PROOF_README.md",
+      "role": "final_bundle_output",
+      "sha256": "9dc65f1351b5891211a2762c76e33c3888f6d4e05e1f5dc33df0954e53d84da6",
+      "size_bytes": 5534
+    },
+    {
+      "absolute_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\final_proof\\FINAL_RECEIPT_SUMMARY.json",
+      "exists": true,
+      "path": "FINAL_RECEIPT_SUMMARY.json",
+      "role": "final_bundle_output",
+      "sha256": "e7a72987c737f87cd8ede33de7206349952a3ecc1a6c7f547d383c9c19abeee1",
+      "size_bytes": 25158
+    },
+    {
+      "absolute_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\final_proof\\REPRO_COMMANDS.txt",
+      "exists": true,
+      "path": "REPRO_COMMANDS.txt",
+      "role": "final_bundle_output",
+      "sha256": "975ba3c0ebdb7c5dd248e75ee4c03a5dd0ca832cf32e8917da920afa8667f363",
+      "size_bytes": 2043
+    },
+    {
+      "absolute_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\final_proof\\STATIC_ORACLE_REPLAY_REPORT.json",
+      "exists": true,
+      "path": "STATIC_ORACLE_REPLAY_REPORT.json",
+      "role": "final_bundle_output",
+      "sha256": "55f09392a6a1166990c6349959fba676149e7d761bc1579c60636e8e2970a5a8",
+      "size_bytes": 18230
+    },
+    {
+      "absolute_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\final_proof\\KNOWN_LIMITS.md",
+      "exists": true,
+      "path": "KNOWN_LIMITS.md",
+      "role": "final_bundle_output",
+      "sha256": "529ec1c050d1ada363dfc1bfce17d1be823b7f282a915678e7b895346da5efd4",
+      "size_bytes": 1306
+    },
+    {
+      "absolute_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\final_proof\\A_GRADE_PROMOTION_REPORT.json",
+      "exists": true,
+      "path": "A_GRADE_PROMOTION_REPORT.json",
+      "role": "final_bundle_output",
+      "sha256": "8ad18619c8e593c0f0e1d17864fa52a9882f9829feb27ac00560545fbdd6049a",
+      "size_bytes": 28860
+    },
+    {
+      "absolute_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\final_proof\\A_GRADE_PROMOTION_README.md",
+      "exists": true,
+      "path": "A_GRADE_PROMOTION_README.md",
+      "role": "final_bundle_output",
+      "sha256": "5f2f3ea1974e43f1defa62831a6d79d1c4f2e66700fe1d5f6dc152514ce33939",
+      "size_bytes": 1489
+    },
+    {
+      "absolute_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\final_proof\\NO_COST_CONFIDENCE_REPORT.json",
+      "exists": true,
+      "path": "NO_COST_CONFIDENCE_REPORT.json",
+      "role": "final_bundle_output",
+      "sha256": "081061a5b5bdda980854336936b03218f083a150cc1120311da3364fb764a7d8",
+      "size_bytes": 28924
+    },
+    {
+      "absolute_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\final_proof\\NO_COST_CONFIDENCE_README.md",
+      "exists": true,
+      "path": "NO_COST_CONFIDENCE_README.md",
+      "role": "final_bundle_output",
+      "sha256": "0da33294abcda04a421a4bb27ea02cd2d656983c6c75f28adc04ecb1b41bbab0",
+      "size_bytes": 1561
+    }
+  ],
+  "bundle_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\final_proof",
+  "generated_utc": "2026-05-23T15:02:34+00:00",
+  "manifest_payload_hash": "5e97ab3467cc265a15902e1e9bd803c034744fc6487152b4a41389d364776f59",
+  "manifest_version": "carddemo_final_proof_manifest_v0",
+  "public_actions_allowed": false,
+  "referenced_existing_artifacts": [
+    {
+      "absolute_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\reports\\modernization_receipt.json",
+      "exists": true,
+      "path": "reports/modernization_receipt.json",
+      "role": "referenced_evidence",
+      "sha256": "fe8b6f2b11d60f9085c8b6b9fd37d8fa41012b390ffdded4207bf970131b3590",
+      "size_bytes": 27485
+    },
+    {
+      "absolute_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\reports\\parity_gap_report.json",
+      "exists": true,
+      "path": "reports/parity_gap_report.json",
+      "role": "referenced_evidence",
+      "sha256": "4fea2ff8f8383a188b0156f9c98876a32fc6aab7794e6a0cb3824ae5bd755c75",
+      "size_bytes": 2298
+    },
+    {
+      "absolute_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\reports\\capability_ledger.json",
+      "exists": true,
+      "path": "reports/capability_ledger.json",
+      "role": "referenced_evidence",
+      "sha256": "ef96f795ea230024bad6a8694898f8e31491a3e6ccc7e2b8879d0eea6cab0c97",
+      "size_bytes": 56984
+    },
+    {
+      "absolute_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\reports\\golden_traces.json",
+      "exists": true,
+      "path": "reports/golden_traces.json",
+      "role": "referenced_evidence",
+      "sha256": "076eb929e91912ffa6e8e633d79ca728e81980bad26bea4370f33b315a2d4eef",
+      "size_bytes": 22277
+    },
+    {
+      "absolute_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\reports\\edge_cases.json",
+      "exists": true,
+      "path": "reports/edge_cases.json",
+      "role": "referenced_evidence",
+      "sha256": "71bc1bb1be6e08528121e41195b07a4057e9ed6c4350c251e163442a16b3819a",
+      "size_bytes": 17467
+    },
+    {
+      "absolute_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\reports\\next_gap_ranking.json",
+      "exists": true,
+      "path": "reports/next_gap_ranking.json",
+      "role": "referenced_evidence",
+      "sha256": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945",
+      "size_bytes": 2
+    },
+    {
+      "absolute_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\reports\\static_oracle_replay.json",
+      "exists": true,
+      "path": "reports/static_oracle_replay.json",
+      "role": "referenced_evidence",
+      "sha256": "55f09392a6a1166990c6349959fba676149e7d761bc1579c60636e8e2970a5a8",
+      "size_bytes": 18230
+    },
+    {
+      "absolute_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\reports\\ui_batch_reports_smoke.png",
+      "exists": true,
+      "path": "reports/ui_batch_reports_smoke.png",
+      "role": "referenced_evidence",
+      "sha256": "f192f2b751ee902b70defbb5b49b745bbf8855a10bb8dc23d60e6c8bb9f6e537",
+      "size_bytes": 69723
+    },
+    {
+      "absolute_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\final_proof\\CLEAN_REPRO_VERIFICATION.json",
+      "exists": true,
+      "path": "final_proof/CLEAN_REPRO_VERIFICATION.json",
+      "role": "referenced_evidence",
+      "sha256": "5adda5d20e306a2c4d5cdcc316d669a99cb8d63043c055362862d43fb06f6d02",
+      "size_bytes": 15468
+    }
+  ]
+}

final_proof/A_GRADE_PROMOTION_README.md

@@ -0,0 +1,37 @@
+# AWS CardDemo A-Grade Promotion Gate
+
+Report version: `carddemo_a_grade_promotion_readme_v0`
+
+This file records the attempt to promote the AWS CardDemo modernization proof from B-grade static/source-oracle parity to A-grade live runtime parity.
+
+## Decision
+
+- Action: `do_not_promote`
+- Promotable to A: `False`
+- Current grade counts: `{'A': 0, 'B': 50, 'C': 0, 'F': 0}`
+- Required live legacy runtime matches: `50`
+- Accepted live legacy runtime matches: `0`
+- Missing live legacy runtime matches: `50`
+- Current static/source-oracle status: B=`50`, F=`0`, gaps=`0`
+
+## Rubric Boundary
+
+A-grade is reserved for actual legacy COBOL/CICS runtime traces matched against modern observed behavior for each capability. The existing proof remains B=50/F=0/gaps=0 under the current static/source-oracle rubric.
+
+This is not live COBOL/CICS all-path runtime equivalence.
+
+## Replay Command
+
+```powershell
+python tools\evaluate_a_grade_promotion.py --source-root ..\source --out-dir .\final_proof
+```
+
+To test a future live trace corpus, add:
+
+```powershell
+--legacy-trace-dir <path-to-live-trace-json-corpus>
+```
+
+## Required Trace Contract
+
+Each accepted live trace record must include the fields listed in `A_GRADE_PROMOTION_REPORT.json` under `legacy_runtime_trace_contract`. The key requirements are: pinned source head, live trace kind, matched=true, a capability ID from the ledger, and SHA-256 hashes for the raw legacy trace and modern observation.

final_proof/A_GRADE_PROMOTION_REPORT.json

@@ -0,0 +1,867 @@
+{
+  "a_grade_gate": {
+    "accepted_live_matches": 0,
+    "current_A": 0,
+    "missing_capability_ids": [
+      "batch:ACCTFILE",
+      "batch:CARDFILE",
+      "batch:CBPAUP0J",
+      "batch:CLOSEFIL",
+      "batch:COMBTRAN",
+      "batch:CREADB21",
+      "batch:CREASTMT",
+      "batch:CUSTFILE",
+      "batch:DEFGDGB",
+      "batch:DEFGDGD",
+      "batch:DISCGRP",
+      "batch:DUSRSECJ",
+      "batch:ESDSRRDS",
+      "batch:INTCALC",
+      "batch:MNTTRDB2",
+      "batch:OPENFIL",
+      "batch:POSTTRAN",
+      "batch:TCATBALF",
+      "batch:TRANBKP",
+      "batch:TRANCATG",
+      "batch:TRANEXTR",
+      "batch:TRANFILE",
+      "batch:TRANIDX",
+      "batch:TRANREPT",
+      "batch:TRANTYPE",
+      "batch:XREFFILE",
+      "online:CA00",
+      "online:CAUP",
+      "online:CAVW",
+      "online:CB00",
+      "online:CC00",
+      "online:CCDL",
+      "online:CCLI",
+      "online:CCUP",
+      "online:CDRA",
+      "online:CDRD",
+      "online:CM00",
+      "online:CP00",
+      "online:CPVD",
+      "online:CPVS",
+      "online:CR00",
+      "online:CT00",
+      "online:CT01",
+      "online:CT02",
+      "online:CTLI",
+      "online:CTTU",
+      "online:CU00",
+      "online:CU01",
+      "online:CU02",
+      "online:CU03"
+    ],
+    "missing_live_matches": 50,
+    "promotable_to_A": false,
+    "proposed_grade_counts_if_gate_passes": {
+      "A": 0,
+      "B": 50,
+      "C": 0,
+      "F": 0
+    },
+    "required_live_matches": 50,
+    "target_A": 50
+  },
+  "blockers": [
+    {
+      "code": "missing_live_legacy_trace_corpus",
+      "detail": "A-grade requires accepted live legacy runtime matches for all 50 capabilities; accepted=0, missing=50."
+    },
+    {
+      "code": "runtime_assets_not_execution_evidence",
+      "detail": "AWS M2/Micro Focus/UniKix package artifacts were found, but this run did not execute them to produce COBOL/CICS transaction traces."
+    },
+    {
+      "code": "no_local_mainframe_or_aws_runtime_path_detected",
+      "detail": "Neither AWS CLI nor a local mainframe emulator was detected for a runtime capture path."
+    },
+    {
+      "code": "static_oracle_is_not_a_grade",
+      "detail": "The current B=50 proof is strong static/source-oracle evidence, but A requires live runtime traces."
+    }
+  ],
+  "capability_match_status": [
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:ACCTFILE",
+      "current_proof_grade": "B",
+      "function": "Refresh Account Master",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "IDCAMS",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:CARDFILE",
+      "current_proof_grade": "B",
+      "function": "Refresh Card Master",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "IDCAMS",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:CBPAUP0J",
+      "current_proof_grade": "B",
+      "function": "Purge Expired Authorizations",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "CBPAUP0C",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:CLOSEFIL",
+      "current_proof_grade": "B",
+      "function": "Close VSAM files in CICS",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "IEFBR14",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:COMBTRAN",
+      "current_proof_grade": "B",
+      "function": "Combine transaction files",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "SORT",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:CREADB21",
+      "current_proof_grade": "B",
+      "function": "Creates CardDemo Db2 database and loads tables",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "DSNTEP4",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:CREASTMT",
+      "current_proof_grade": "B",
+      "function": "Produce transaction statement",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "CBSTM03A",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:CUSTFILE",
+      "current_proof_grade": "B",
+      "function": "Refresh Customer Master",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "IDCAMS",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:DEFGDGB",
+      "current_proof_grade": "B",
+      "function": "Setup GDG Bases",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "IDCAMS",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:DEFGDGD",
+      "current_proof_grade": "B",
+      "function": "Setup more GDG Bases for Db2",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "IDCAMS",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:DISCGRP",
+      "current_proof_grade": "B",
+      "function": "Load Disclosure Group File",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "IDCAMS",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:DUSRSECJ",
+      "current_proof_grade": "B",
+      "function": "Initial Load of User security file",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "IEBGENER",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:ESDSRRDS",
+      "current_proof_grade": "B",
+      "function": "Create ESDS and RRDS VSAM files",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "IDCAMS",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:INTCALC",
+      "current_proof_grade": "B",
+      "function": "Run interest calculations",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "CBACT04C",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:MNTTRDB2",
+      "current_proof_grade": "B",
+      "function": "Maintain Transaction type table",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COBTUPDT",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:OPENFIL",
+      "current_proof_grade": "B",
+      "function": "Open files in CICS",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "IEFBR14",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:POSTTRAN",
+      "current_proof_grade": "B",
+      "function": "Transaction processing job",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "CBTRN02C",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:TCATBALF",
+      "current_proof_grade": "B",
+      "function": "Refresh Transaction Category Balance",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "IDCAMS",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:TRANBKP",
+      "current_proof_grade": "B",
+      "function": "Refresh Transaction Master",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "IDCAMS",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:TRANCATG",
+      "current_proof_grade": "B",
+      "function": "Load Transaction category types",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "IDCAMS",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:TRANEXTR",
+      "current_proof_grade": "B",
+      "function": "Extracts latest Db2 data for Transaction types",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "DSNTIAUL",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:TRANFILE",
+      "current_proof_grade": "B",
+      "function": "Load Transaction Master file",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "IDCAMS",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:TRANIDX",
+      "current_proof_grade": "B",
+      "function": "Define AIX for transaction file",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "IDCAMS",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:TRANREPT",
+      "current_proof_grade": "B",
+      "function": "Transaction Report - Submitted from CICS",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "CBTRN03C",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:TRANTYPE",
+      "current_proof_grade": "B",
+      "function": "Load Transaction type file",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "IDCAMS",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "batch:XREFFILE",
+      "current_proof_grade": "B",
+      "function": "Account, Card and Customer cross reference",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "IDCAMS",
+      "surface": "batch",
+      "transaction": ""
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CA00",
+      "current_proof_grade": "B",
+      "function": "Admin Menu",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COADM01C",
+      "surface": "online",
+      "transaction": "CA00"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CAUP",
+      "current_proof_grade": "B",
+      "function": "Account Update",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COACTUPC",
+      "surface": "online",
+      "transaction": "CAUP"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CAVW",
+      "current_proof_grade": "B",
+      "function": "Account View",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COACTVWC",
+      "surface": "online",
+      "transaction": "CAVW"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CB00",
+      "current_proof_grade": "B",
+      "function": "Bill Payment",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COBIL00C",
+      "surface": "online",
+      "transaction": "CB00"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CC00",
+      "current_proof_grade": "B",
+      "function": "Signon Screen",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COSGN00C",
+      "surface": "online",
+      "transaction": "CC00"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CCDL",
+      "current_proof_grade": "B",
+      "function": "Credit Card View",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COCRDSLC",
+      "surface": "online",
+      "transaction": "CCDL"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CCLI",
+      "current_proof_grade": "B",
+      "function": "Credit Card List",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COCRDLIC",
+      "surface": "online",
+      "transaction": "CCLI"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CCUP",
+      "current_proof_grade": "B",
+      "function": "Credit Card Update",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COCRDUPC",
+      "surface": "online",
+      "transaction": "CCUP"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CDRA",
+      "current_proof_grade": "B",
+      "function": "Inquire account details via MQ",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COACCT01",
+      "surface": "online",
+      "transaction": "CDRA"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CDRD",
+      "current_proof_grade": "B",
+      "function": "Inquire System Date via MQ",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "CODATE01",
+      "surface": "online",
+      "transaction": "CDRD"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CM00",
+      "current_proof_grade": "B",
+      "function": "Main Menu",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COMEN01C",
+      "surface": "online",
+      "transaction": "CM00"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CP00",
+      "current_proof_grade": "B",
+      "function": "Process Authorization Requests",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COPAUA0C",
+      "surface": "online",
+      "transaction": "CP00"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CPVD",
+      "current_proof_grade": "B",
+      "function": "Pending Authorization Details",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COPAUS1C",
+      "surface": "online",
+      "transaction": "CPVD"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CPVS",
+      "current_proof_grade": "B",
+      "function": "Pending Authorization Summary",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COPAUS0C",
+      "surface": "online",
+      "transaction": "CPVS"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CR00",
+      "current_proof_grade": "B",
+      "function": "Transaction Reports",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "CORPT00C",
+      "surface": "online",
+      "transaction": "CR00"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CT00",
+      "current_proof_grade": "B",
+      "function": "Transaction List",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COTRN00C",
+      "surface": "online",
+      "transaction": "CT00"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CT01",
+      "current_proof_grade": "B",
+      "function": "Transaction View",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COTRN01C",
+      "surface": "online",
+      "transaction": "CT01"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CT02",
+      "current_proof_grade": "B",
+      "function": "Transaction Add",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COTRN02C",
+      "surface": "online",
+      "transaction": "CT02"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CTLI",
+      "current_proof_grade": "B",
+      "function": "Tran Type list/update/delete",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COTRTLIC",
+      "surface": "online",
+      "transaction": "CTLI"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CTTU",
+      "current_proof_grade": "B",
+      "function": "Tran Type add/edit",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COTRTUPC",
+      "surface": "online",
+      "transaction": "CTTU"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CU00",
+      "current_proof_grade": "B",
+      "function": "List Users",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COUSR00C",
+      "surface": "online",
+      "transaction": "CU00"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CU01",
+      "current_proof_grade": "B",
+      "function": "Add User",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COUSR01C",
+      "surface": "online",
+      "transaction": "CU01"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CU02",
+      "current_proof_grade": "B",
+      "function": "Update User",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COUSR02C",
+      "surface": "online",
+      "transaction": "CU02"
+    },
+    {
+      "a_grade_match_found": false,
+      "accepted_trace": null,
+      "capability_id": "online:CU03",
+      "current_proof_grade": "B",
+      "function": "Delete User",
+      "missing_reason": "no_accepted_live_legacy_runtime_trace",
+      "program": "COUSR03C",
+      "surface": "online",
+      "transaction": "CU03"
+    }
+  ],
+  "current_static_source_oracle_status": {
+    "capability_count": 50,
+    "gap_count": 0,
+    "grade_counts": {
+      "A": 0,
+      "B": 50,
+      "C": 0,
+      "F": 0
+    },
+    "receipt_generated_utc": "2026-05-23T15:01:51+00:00",
+    "receipt_hash": "fea9dfeca8e1b400afe6fbf4a25f92282a6330da0bb031f87b8dbd6e41044819",
+    "static_oracle_or_better_count": 50,
+    "strict_runtime_parity_count": 0
+  },
+  "decision": {
+    "action": "do_not_promote",
+    "next_non_human_path": [
+      "Run the pinned AWS CardDemo source in an AWS M2/mainframe-compatible runtime.",
+      "Capture transaction and batch outputs for each capability ID in reports/capability_ledger.json.",
+      "Replay the same inputs through the modern Python/SQLite service.",
+      "Emit JSON trace records satisfying legacy_runtime_trace_contract.",
+      "Rerun this gate with --legacy-trace-dir pointing at that corpus."
+    ],
+    "why": "The current bundle proves B=50/F=0/gaps=0 under the static/source-oracle rubric, but it does not contain accepted live COBOL/CICS runtime traces for all capabilities."
+  },
+  "generated_utc": "2026-05-23T15:01:52+00:00",
+  "legacy_runtime_environment_assessment": {
+    "local_execution_path_found": false,
+    "local_execution_path_reason": "No runnable COBOL/CICS/VSAM/JCL runtime was executed in this workspace. Static replay and modern API tests are not live legacy execution.",
+    "runtime_assets": [
+      {
+        "entry_count": 112,
+        "exists": true,
+        "has_app_config": true,
+        "has_catalog_data": false,
+        "has_catalog_jcl": false,
+        "has_shared_load_modules": false,
+        "has_unikix_layout": false,
+        "path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\source\\samples\\m2\\mf\\CardDemo_runtime.zip",
+        "runtime_conclusion": "Deployment/runtime asset detected. This is useful provenance, but it is not a live executed COBOL/CICS trace corpus by itself.",
+        "sample_entries": [
+          "loadlib/",
+          "loadlib/COCRDUPC.so",
+          "loadlib/COTRN02.MOD",
+          "loadlib/CBACT02C.so",
+          "loadlib/COUSR02C.so",
+          "loadlib/CORPT00C.so",
+          "loadlib/COUSR03C.so",
+          "loadlib/CBACT03C.so",
+          "loadlib/COTRN01.MOD",
+          "loadlib/CBACT01C.so",
+          "loadlib/COACTVW.MOD",
+          "loadlib/COSGN00.MOD",
+          "loadlib/COUSR01C.so",
+          "loadlib/COACTUPC.so",
+          "loadlib/COUSR00C.so",
+          "loadlib/CBSTM03B.so",
+          "loadlib/COTRN00.MOD",
+          "loadlib/CBACT04C.so",
+          "loadlib/COBIL00C.so",
+          "loadlib/COCRDLI.MOD",
+          "loadlib/CBCUS01C.so",
+          "loadlib/COCRDSL.MOD",
+          "loadlib/COMEN01.MOD",
+          "loadlib/COADM01.MOD",
+          "loadlib/COMEN01C.so",
+          "loadlib/COCRDSLC.so",
+          "loadlib/CBTRN03C.so",
+          "loadlib/CBTRN02C.so",
+          "loadlib/COADM01C.so",
+          "loadlib/CBTRN01C.so"
+        ],
+        "sha256": "683ef5bb461553ae9cee17c8c115f63bcb241ddeb832a2f1c62e8f96e9dbe2e3",
+        "size_bytes": 468566
+      },
+      {
+        "entry_count": 381,
+        "exists": true,
+        "has_app_config": false,
+        "has_catalog_data": false,
+        "has_catalog_jcl": false,
+        "has_shared_load_modules": false,
+        "has_unikix_layout": true,
+        "path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\source\\samples\\m2\\unikix\\UniKix_CardDemo_runtime_v1.zip",
+        "runtime_conclusion": "Deployment/runtime asset detected. This is useful provenance, but it is not a live executed COBOL/CICS trace corpus by itself.",
+        "sample_entries": [
+          "bin/",
+          "__MACOSX/._bin",
+          "bin/compbms",
+          "__MACOSX/bin/._compbms",
+          "bin/compile.all",
+          "__MACOSX/bin/._compile.all",
+          "bin/carddemo.env",
+          "bin/create_project",
+          "__MACOSX/bin/._create_project",
+          "bin/compile",
+          "__MACOSX/bin/._compile",
+          "bin/compbms.all",
+          "__MACOSX/bin/._compbms.all",
+          "bin/deploy_app",
+          "__MACOSX/bin/._deploy_app",
+          "migrated_app/",
+          "__MACOSX/._migrated_app",
+          "migrated_app/proc/",
+          "migrated_app/.DS_Store",
+          "__MACOSX/migrated_app/._.DS_Store",
+          "migrated_app/jcl/",
+          "migrated_app/catlg/",
+          "migrated_app/cpy-bms/",
+          "migrated_app/bms/",
+          "migrated_app/cbl/",
+          "migrated_app/cpy/",
+          "migrated_app/ctl/",
+          "migrated_app/data/",
+          "migrated_app/proc/REPROC",
+          "__MACOSX/migrated_app/proc/._REPROC"
+        ],
+        "sha256": "431f67920a1e9b980cc21a6de1a375aac0c21b62d256c584d109ff7735c436ca",
+        "size_bytes": 434174
+      }
+    ],
+    "source_prerequisites": [
+      "mainframe environment with CICS, VSAM, and JCL support",
+      "optional DB2, IMS DB, and MQ paths for optional modules"
+    ],
+    "tooling_probe": {
+      "aws": {
+        "path": null,
+        "present": false,
+        "purpose": "AWS CLI; needed for AWS-hosted M2/Mainframe runtime paths.",
+        "tool": "aws"
+      },
+      "cobc": {
+        "path": null,
+        "present": false,
+        "purpose": "GnuCOBOL compiler; useful for limited COBOL probes, not sufficient for CICS/VSAM/JCL parity.",
+        "tool": "cobc"
+      },
+      "docker": {
+        "path": "C:\\Program Files\\Docker\\Docker\\resources\\bin\\docker.EXE",
+        "present": true,
+        "purpose": "Container runtime; useful only when a licensed/runnable legacy runtime image exists.",
+        "tool": "docker",
+        "version_probe_ok": true,
+        "version_probe_output": "\"29.1.2\"",
+        "version_probe_returncode": 0
+      },
+      "gradle": {
+        "path": null,
+        "present": false,
+        "purpose": "Gradle; useful for Java-based runtime harnesses.",
+        "tool": "gradle"
+      },
+      "hercules": {
+        "path": null,
+        "present": false,
+        "purpose": "Mainframe emulator; still not a CICS/VSAM/JCL runtime by itself.",
+        "tool": "hercules"
+      },
+      "java": {
+        "path": null,
+        "present": false,
+        "purpose": "JVM; required by several migration/runtime toolchains.",
+        "tool": "java"
+      },
+      "mvn": {
+        "path": null,
+        "present": false,
+        "purpose": "Maven; useful for Java-based runtime harnesses.",
+        "tool": "mvn"
+      },
+      "tn3270": {
+        "path": null,
+        "present": false,
+        "purpose": "3270 terminal client; useful for interactive CICS transaction capture.",
+        "tool": "tn3270"
+      }
+    }
+  },
+  "legacy_runtime_trace_contract": {
+    "accepted_trace_kinds": [
+      "live_cobol_cics_runtime",
+      "live_mainframe_runtime"
+    ],
+    "field_rules": {
+      "capability_id": "must match one ID in reports/capability_ledger.json",
+      "hash_fields": "64-character SHA-256 hex digests",
+      "matched": true,
+      "source_head": "59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e"
+    },
+    "required_fields": [
+      "capability_id",
+      "trace_kind",
+      "source_head",
+      "legacy_runtime_environment",
+      "modern_observation_hash",
+      "comparator_version",
+      "matched",
+      "raw_legacy_trace_hash or legacy_runtime_trace_hash"
+    ]
+  },
+  "live_trace_scan": {
+    "accepted_matches": {},
+    "files_scanned": [],
+    "rejected_records": [],
+    "trace_dir": null,
+    "trace_dir_exists": false
+  },
+  "modern_code": {
+    "local_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo"
+  },
+  "public_actions_allowed": false,
+  "report_hash": "4f962c34517806cf2dee00f3fdd0b7c4f51e9ec3f5935eedfabd04104e3ad3af",
+  "report_version": "carddemo_a_grade_promotion_gate_v0",
+  "requested_target": {
+    "capability_count": 50,
+    "grade": "A",
+    "scope": "all capabilities"
+  },
+  "rubric": {
+    "A": "actual legacy COBOL/CICS runtime trace matched to modern observed behavior for the capability",
+    "B": "static legacy data/copybook/source-oracle match plus executable modern-service replay",
+    "F": "known parity gap or missing capability under the current rubric"
+  },
+  "source": {
+    "head": "59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e",
+    "local_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\source",
+    "repo_url": "https://github.com/aws-samples/aws-mainframe-modernization-carddemo.git"
+  }
+}

final_proof/CLEAN_REPRO_VERIFICATION.json

@@ -0,0 +1,197 @@
+{
+  "api_smoke": {
+    "batch_resource_setup_tranidx": {
+      "alternate_index": {
+        "cylinders": [
+          5,
+          1
+        ],
+        "data": "AWS.M2.CARDDEMO.TRANSACT.VSAM.AIX.DATA",
+        "index": "AWS.M2.CARDDEMO.TRANSACT.VSAM.AIX.INDEX",
+        "keys": {
+          "length": 26,
+          "offset": 304
+        },
+        "name": "AWS.M2.CARDDEMO.TRANSACT.VSAM.AIX",
+        "nonunique": true,
+        "record_size": [
+          350,
+          350
+        ],
+        "relate": "AWS.M2.CARDDEMO.TRANSACT.VSAM.KSDS",
+        "upgrade": true,
+        "volume": "AWSHJ1"
+      },
+      "bldindex": {
+        "indataset": "AWS.M2.CARDDEMO.TRANSACT.VSAM.KSDS",
+        "outdataset": "AWS.M2.CARDDEMO.TRANSACT.VSAM.AIX",
+        "source_record_count": 300
+      },
+      "function": "Define AIX for transaction file",
+      "legacy_job": "TRANIDX",
+      "legacy_program": "IDCAMS",
+      "path": {
+        "name": "AWS.M2.CARDDEMO.TRANSACT.VSAM.AIX.PATH",
+        "pathentry": "AWS.M2.CARDDEMO.TRANSACT.VSAM.AIX"
+      },
+      "source_oracle": "TRANIDX.jcl DEFINE ALTERNATEINDEX, DEFINE PATH, and BLDINDEX statements",
+      "steps": [
+        {
+          "control": "DEFINE ALTERNATEINDEX",
+          "program": "IDCAMS",
+          "step": "STEP20"
+        },
+        {
+          "control": "DEFINE PATH",
+          "program": "IDCAMS",
+          "step": "STEP25"
+        },
+        {
+          "control": "BLDINDEX",
+          "program": "IDCAMS",
+          "step": "STEP30"
+        }
+      ]
+    },
+    "health": {
+      "source_root": "..\\source",
+      "status": "ok"
+    },
+    "mq_system_date": {
+      "error_queue": "CARD.DEMO.ERROR.QUEUE",
+      "input_queue": "CARD.DEMO.REQUEST.DATE",
+      "legacy_pattern": "MQ request/reply",
+      "legacy_program": "CODATE01",
+      "legacy_transaction": "CDRD",
+      "message_format": {
+        "correlation": "reply reuses MQMD message id and correl id",
+        "mq_format": "MQFMT_STRING",
+        "reply_length": 1000,
+        "request_copy": "REQUEST-MSG-COPY"
+      },
+      "reply_message": "SYSTEM DATE : 05-23-2026SYSTEM TIME : 11:12:13",
+      "reply_queue": "CARD.DEMO.REPLY.DATE",
+      "request_message": "DATE                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ",
+      "source_oracle": "CODATE01 4000-PROCESS-REQUEST-REPLY uses CICS ASKTIME/FORMATTIME MMDDYYYY DATESEP('-') TIMESEP and does not validate WS-FUNC",
+      "system_date": "05-23-2026",
+      "system_time": "11:12:13"
+    },
+    "summary": {
+      "claim_limit": "capability ledger and static-oracle traces only; no all-path COBOL runtime proof yet",
+      "counts": {
+        "accounts": 50,
+        "authorization_frauds": 0,
+        "card_xrefs": 50,
+        "cards": 50,
+        "customers": 50,
+        "disclosure_groups": 51,
+        "pending_authorization_details": 202,
+        "pending_authorization_summaries": 21,
+        "transaction_categories": 18,
+        "transaction_category_balances": 50,
+        "transaction_types": 7,
+        "transactions": 300,
+        "users": 10
+      },
+      "portfolio": {
+        "credit_limit": "233711.00",
+        "current_balance": "12269.00"
+      }
+    }
+  },
+  "api_smoke_passed": true,
+  "commands": [
+    {
+      "command": "C:\\Users\\Cjc00\\AppData\\Local\\Programs\\Python\\Python311\\python.exe -m carddemo.cli init-db --source-root ..\\source --db-path .\\carddemo.sqlite",
+      "cwd": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z\\modern_carddemo",
+      "duration_seconds": 0.781,
+      "name": "setup",
+      "passed": true,
+      "returncode": 0,
+      "stderr_tail": "",
+      "stdout_tail": "{'customers': 50, 'accounts': 50, 'cards': 50, 'card_xrefs': 50, 'transactions': 300, 'transaction_types': 7, 'transaction_categories': 18, 'disclosure_groups': 51, 'transaction_category_balances': 50, 'users': 10, 'pending_authorization_summaries': 21, 'pending_authorization_details': 202}\n"
+    },
+    {
+      "command": "C:\\Users\\Cjc00\\AppData\\Local\\Programs\\Python\\Python311\\python.exe -m unittest discover -s tests",
+      "cwd": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z\\modern_carddemo",
+      "duration_seconds": 21.297,
+      "name": "test",
+      "passed": true,
+      "returncode": 0,
+      "stderr_tail": "..................................................\n----------------------------------------------------------------------\nRan 50 tests in 20.718s\n\nOK\n",
+      "stdout_tail": ""
+    },
+    {
+      "command": "C:\\Users\\Cjc00\\AppData\\Local\\Programs\\Python\\Python311\\python.exe tools\\generate_receipts.py --source-root ..\\source --db-path .\\carddemo.sqlite --out-dir .\\reports",
+      "cwd": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z\\modern_carddemo",
+      "duration_seconds": 0.797,
+      "name": "receipt",
+      "passed": true,
+      "returncode": 0,
+      "stderr_tail": "",
+      "stdout_tail": "{\n  \"receipt\": \"reports\\\\modernization_receipt.json\",\n  \"parity\": \"reports\\\\parity_gap_report.json\",\n  \"passed\": true\n}\n"
+    },
+    {
+      "command": "C:\\Users\\Cjc00\\AppData\\Local\\Programs\\Python\\Python311\\python.exe tools\\replay_static_oracles.py --source-root ..\\source --out-dir .\\reports --source-head 59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e",
+      "cwd": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z\\modern_carddemo",
+      "duration_seconds": 0.516,
+      "name": "static_oracle_replay",
+      "passed": true,
+      "returncode": 0,
+      "stderr_tail": "",
+      "stdout_tail": "{\n  \"replay\": \"reports\\\\static_oracle_replay.json\",\n  \"passed\": true,\n  \"replay_hash\": \"da60110c66ee3b44432933de91afec1ba09dcbc9551f4495933f9eba3779f56e\",\n  \"failed_checks\": [],\n  \"claim_limit\": \"Executable modern replay over static/source-oracle traces only; no live COBOL/CICS runtime replay has been performed.\"\n}\n"
+    },
+    {
+      "command": "C:\\Users\\Cjc00\\AppData\\Local\\Programs\\Python\\Python311\\python.exe tools\\evaluate_a_grade_promotion.py --source-root ..\\source --out-dir .\\final_proof",
+      "cwd": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z\\modern_carddemo",
+      "duration_seconds": 0.234,
+      "name": "a_grade_promotion",
+      "passed": true,
+      "returncode": 0,
+      "stderr_tail": "",
+      "stdout_tail": "{\n  \"accepted_live_matches\": 0,\n  \"current_grade_counts\": {\n    \"A\": 0,\n    \"B\": 50,\n    \"C\": 0,\n    \"F\": 0\n  },\n  \"missing_live_matches\": 50,\n  \"out_dir\": \"D:\\\\scraper_storage\\\\modernization_labs\\\\aws-carddemo-modernization-20260523T073000Z\\\\clean_repro_20260523T150205Z\\\\modern_carddemo\\\\final_proof\",\n  \"promotable_to_A\": false,\n  \"report_hash\": \"88b3cc4916145340ed2dec0135ba25ee1b9ddd4029c7e1e4aedb586643286544\",\n  \"required_live_matches\": 50\n}\n"
+    },
+    {
+      "command": "C:\\Users\\Cjc00\\AppData\\Local\\Programs\\Python\\Python311\\python.exe tools\\build_no_cost_confidence.py --source-root ..\\source --out-dir .\\final_proof",
+      "cwd": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z\\modern_carddemo",
+      "duration_seconds": 0.578,
+      "name": "no_cost_confidence",
+      "passed": true,
+      "returncode": 0,
+      "stderr_tail": "",
+      "stdout_tail": "{\n  \"out_dir\": \"D:\\\\scraper_storage\\\\modernization_labs\\\\aws-carddemo-modernization-20260523T073000Z\\\\clean_repro_20260523T150205Z\\\\modern_carddemo\\\\final_proof\",\n  \"ready_for_pre_runtime_review\": true,\n  \"report_hash\": \"20fd4a66a6fa52e75037c4ca5a6c389f613eefa9fdcc4087c036c6b355145c1a\",\n  \"reviewer_posture\": \"strong_pre_runtime_confidence\",\n  \"status_counts\": {\n    \"pass\": 6,\n    \"warn\": 1\n  }\n}\n"
+    },
+    {
+      "command": "C:\\Users\\Cjc00\\AppData\\Local\\Programs\\Python\\Python311\\python.exe tools\\package_final_proof.py --source-root ..\\source",
+      "cwd": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z\\modern_carddemo",
+      "duration_seconds": 0.313,
+      "name": "package_final_proof",
+      "passed": true,
+      "returncode": 0,
+      "stderr_tail": "",
+      "stdout_tail": "\"report_hash\": \"88b3cc4916145340ed2dec0135ba25ee1b9ddd4029c7e1e4aedb586643286544\",\n    \"report_version\": \"carddemo_a_grade_promotion_gate_v0\",\n    \"required_live_matches\": 50,\n    \"target_A\": 50,\n    \"trace_contract\": {\n      \"accepted_trace_kinds\": [\n        \"live_cobol_cics_runtime\",\n        \"live_mainframe_runtime\"\n      ],\n      \"field_rules\": {\n        \"capability_id\": \"must match one ID in reports/capability_ledger.json\",\n        \"hash_fields\": \"64-character SHA-256 hex digests\",\n        \"matched\": true,\n        \"source_head\": \"59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e\"\n      },\n      \"required_fields\": [\n        \"capability_id\",\n        \"trace_kind\",\n        \"source_head\",\n        \"legacy_runtime_environment\",\n        \"modern_observation_hash\",\n        \"comparator_version\",\n        \"matched\",\n        \"raw_legacy_trace_hash or legacy_runtime_trace_hash\"\n      ]\n    }\n  },\n  \"clean_repro_verification_present\": false,\n  \"files\": [\n    \"FINAL_PROOF_README.md\",\n    \"FINAL_RECEIPT_SUMMARY.json\",\n    \"REPRO_COMMANDS.txt\",\n    \"STATIC_ORACLE_REPLAY_REPORT.json\",\n    \"KNOWN_LIMITS.md\",\n    \"ARTIFACT_MANIFEST.json\"\n  ],\n  \"no_cost_confidence\": {\n    \"a_missing_live_matches\": 50,\n    \"a_promotable\": false,\n    \"capability_count\": 50,\n    \"edge_case_count\": 40,\n    \"generated_utc\": \"2026-05-23T15:02:32+00:00\",\n    \"golden_trace_count\": 34,\n    \"legacy_runtime_claim_made\": false,\n    \"paid_runtime_used\": false,\n    \"path\": \"D:\\\\scraper_storage\\\\modernization_labs\\\\aws-carddemo-modernization-20260523T073000Z\\\\clean_repro_20260523T150205Z\\\\modern_carddemo\\\\final_proof\\\\NO_COST_CONFIDENCE_REPORT.json\",\n    \"readme_path\": \"D:\\\\scraper_storage\\\\modernization_labs\\\\aws-carddemo-modernization-20260523T073000Z\\\\clean_repro_20260523T150205Z\\\\modern_carddemo\\\\final_proof\\\\NO_COST_CONFIDENCE_README.md\",\n    \"ready_for_pre_runtime_review\": true,\n    \"remaining_gap\": \"live legacy COBOL/CICS/VSAM/JCL runtime validation on a real or licensed-compatible runtime\",\n    \"report_hash\": \"20fd4a66a6fa52e75037c4ca5a6c389f613eefa9fdcc4087c036c6b355145c1a\",\n    \"report_version\": \"carddemo_no_cost_confidence_v0\",\n    \"reviewer_posture\": \"strong_pre_runtime_confidence\",\n    \"source_ref_total\": 101,\n    \"static_oracle_ready_count\": 50,\n    \"static_replay_passed\": true\n  },\n  \"out_dir\": \"D:\\\\scraper_storage\\\\modernization_labs\\\\aws-carddemo-modernization-20260523T073000Z\\\\clean_repro_20260523T150205Z\\\\modern_carddemo\\\\final_proof\",\n  \"parity\": {\n    \"B\": 50,\n    \"F\": 0,\n    \"capability_count\": 50,\n    \"gap_count\": 0,\n    \"grade_counts\": {\n      \"A\": 0,\n      \"B\": 50,\n      \"C\": 0,\n      \"F\": 0\n    },\n    \"next_gap_ranking_count\": 0,\n    \"one_for_one_parity_ready\": true,\n    \"parity_hash\": \"677ea1276946f3b2acd1791ad704445c5ecd1d208b8246c4de40b02c773916c4\",\n    \"parity_report_passed\": true,\n    \"proof_grade_meanings\": {\n      \"A\": \"actual legacy runtime trace match\",\n      \"B\": \"static legacy data/copybook oracle match\",\n      \"C\": \"implemented or inferred without strict parity proof\",\n      \"F\": \"discovered capability gap\"\n    },\n    \"rubric\": \"current static/source-oracle rubric\",\n    \"static_oracle_or_better_count\": 50,\n    \"strict_runtime_parity_count\": 0\n  },\n  \"static_oracle_replay\": {\n    \"claim_limit\": \"Executable modern replay over static/source-oracle traces only; no live COBOL/CICS runtime replay has been performed.\",\n    \"evidence_hash\": \"b800ca64245b6229211cc4ace2b7c375f59d6d84afd08d04491c67b2ac50d847\",\n    \"failed_checks\": [],\n    \"passed\": true,\n    \"path\": \"D:\\\\scraper_storage\\\\modernization_labs\\\\aws-carddemo-modernization-20260523T073000Z\\\\clean_repro_20260523T150205Z\\\\modern_carddemo\\\\final_proof\\\\STATIC_ORACLE_REPLAY_REPORT.json\",\n    \"replay_hash\": \"da60110c66ee3b44432933de91afec1ba09dcbc9551f4495933f9eba3779f56e\",\n    \"runtime_probe_count\": 6,\n    \"source_report_path\": \"D:\\\\scraper_storage\\\\modernization_labs\\\\aws-carddemo-modernization-20260523T073000Z\\\\clean_repro_20260523T150205Z\\\\modern_carddemo\\\\reports\\\\static_oracle_replay.json\"\n  }\n}\n"
+    }
+  ],
+  "copied_workspace": {
+    "modern_copy": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z\\modern_carddemo",
+    "scratch_root": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z",
+    "source_copy": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z\\source"
+  },
+  "generated_utc": "2026-05-23T15:02:33+00:00",
+  "passed": true,
+  "server_port": 8091,
+  "server_smoke": {
+    "checks": {
+      "health_ok": true,
+      "mq_date_reply": true,
+      "summary_customers_50": true,
+      "tranidx_key_contract": true
+    },
+    "passed": true,
+    "server_command": "C:\\Users\\Cjc00\\AppData\\Local\\Programs\\Python\\Python311\\python.exe -m carddemo.cli serve --source-root ..\\source --db-path .\\carddemo.sqlite --port 8091",
+    "stderr_log": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z\\modern_carddemo\\server_smoke.err.log",
+    "stdout_log": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z\\modern_carddemo\\server_smoke.out.log"
+  },
+  "source_head": "59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e",
+  "verification_version": "carddemo_clean_repro_verification_v0"
+}

final_proof/FINAL_PROOF_README.md

@@ -0,0 +1,130 @@
+
+# AWS CardDemo Modernization Final Proof
+
+This bundle packages the local AWS CardDemo modernization run as a reproducible technical-review artifact. It does not add application features; it records the source identity, modern code location, commands, receipts, static-oracle replay, no-cost confidence proof, A-grade promotion gate, known limits, and clean-copy verification status.
+
+## Source Identity
+
+- Source repo: `https://github.com/aws-samples/aws-mainframe-modernization-carddemo.git`
+- Source version: `59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e`
+- Source local path used for this run: `D:\scraper_storage\modernization_labs\aws-carddemo-modernization-20260523T073000Z\source`
+- Source file hash count in receipt: `204`
+- Source hash digest over receipt map: `0703f97553bde0f5bd170aa95ec8c771a975b397be7d9e8088ec6fbf31d333c2`
+
+## Modern Code
+
+- Modern code path: `D:\scraper_storage\modernization_labs\aws-carddemo-modernization-20260523T073000Z\modern_carddemo`
+- Modern file hash count in receipt: `29`
+- Modern hash digest over receipt map: `599294a7df7226c4d2a4b820de4bf567abbd1bdd1e41a1b6fd123457cb3abf40`
+
+## One-Command Setup And Run
+
+Run these from the modern code root with the AWS CardDemo source clone/copy at `..\source`.
+
+Setup database:
+
+```powershell
+python -m carddemo.cli init-db --source-root ..\source --db-path .\carddemo.sqlite
+```
+
+Run web/API server:
+
+```powershell
+python -m carddemo.cli serve --source-root ..\source --db-path .\carddemo.sqlite --port 8087
+```
+
+Open `http://127.0.0.1:8087`.
+
+## One-Command Tests
+
+```powershell
+python -m unittest discover -s tests
+```
+
+## One-Command Static-Oracle Replay
+
+```powershell
+python tools\replay_static_oracles.py --source-root ..\source --out-dir .\reports --source-head 59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e
+```
+
+## One-Command A-Grade Promotion Gate
+
+```powershell
+python tools\evaluate_a_grade_promotion.py --source-root ..\source --out-dir .\final_proof
+```
+
+## One-Command No-Cost Confidence Proof
+
+```powershell
+python tools\build_no_cost_confidence.py --source-root ..\source --out-dir .\final_proof
+```
+
+## Full Local Proof Refresh
+
+```powershell
+powershell -NoProfile -Command "python -m carddemo.cli init-db --source-root ..\source --db-path .\carddemo.sqlite; python -m unittest discover -s tests; python tools\generate_receipts.py --source-root ..\source --db-path .\carddemo.sqlite --out-dir .\reports; python tools\replay_static_oracles.py --source-root ..\source --out-dir .\reports --source-head 59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e; python tools\evaluate_a_grade_promotion.py --source-root ..\source --out-dir .\final_proof; python tools\build_no_cost_confidence.py --source-root ..\source --out-dir .\final_proof; python tools\package_final_proof.py --source-root ..\source"
+```
+
+## Final Receipt Summary
+
+- Receipt hash: `fea9dfeca8e1b400afe6fbf4a25f92282a6330da0bb031f87b8dbd6e41044819`
+- Receipt generated: `2026-05-23T15:01:51+00:00`
+- Static replay hash: `912e98e11d46cd967070d06ec17aaed3402bed44026267d1906ea6a2d54b9a42`
+- Static replay passed: `True`
+- Runtime probe count: `6`
+- Failed replay checks: `[]`
+
+## Parity Summary
+
+Under the current static/source-oracle rubric:
+
+- Capability count: `50`
+- B-grade static/source-oracle capabilities: `50`
+- F-grade gaps: `0`
+- Gap count: `0`
+- Next-gap ranking count: `0`
+- Static-oracle-or-better count: `50`
+- A-grade live legacy runtime trace count: `0`
+
+Proof grade meanings are recorded in `FINAL_RECEIPT_SUMMARY.json`.
+
+## No-Cost Confidence Proof
+
+- Reviewer posture: `strong_pre_runtime_confidence`
+- Ready for pre-runtime review: `True`
+- Paid runtime used: `False`
+- Legacy runtime claim made: `False`
+- Source-backed static capabilities: `50`
+- Source refs in capability ledger: `101`
+- Golden traces / edge cases: `34` / `40`
+- Remaining gap: `live legacy COBOL/CICS/VSAM/JCL runtime validation on a real or licensed-compatible runtime`
+- No-cost confidence report hash: `c72a4b6b30b7bbee9096b3d79e2893fb0263d5aee1f4aebaec37401810208441`
+
+This is the maximum unpaid/pre-runtime evidence layer. It is meant to convince a technical reviewer that the modernization is probably functional under the extracted legacy-derived behavior, while preserving the live runtime validation gap.
+
+## A-Grade Promotion Gate
+
+- A-grade gate decision: `do_not_promote`
+- Promotable to A: `False`
+- Required live legacy runtime matches: `50`
+- Accepted live legacy runtime matches: `0`
+- Missing live legacy runtime matches: `50`
+- A-grade report hash: `4f962c34517806cf2dee00f3fdd0b7c4f51e9ec3f5935eedfabd04104e3ad3af`
+
+The A-grade gate is intentionally stricter than the B-grade static/source-oracle proof. It requires accepted live legacy COBOL/CICS runtime trace matches for each capability before any capability can be promoted to A.
+
+## Smoke Evidence
+
+- Screenshot: `reports/ui_batch_reports_smoke.png` SHA-256 `f192f2b751ee902b70defbb5b49b745bbf8855a10bb8dc23d60e6c8bb9f6e537`.
+- Clean-copy API smoke: passed=True port=8091 endpoints=batch_resource_setup_tranidx, health, mq_system_date, summary.
+
+## Clean-Copy Verification
+
+- Clean-copy verification status: `passed`
+- Verification report included in `FINAL_RECEIPT_SUMMARY.json` when present.
+
+## Caveat
+
+This proof is static/source-oracle parity plus executable modern-service replay. It is not live COBOL/CICS all-path runtime equivalence.
+
+See `KNOWN_LIMITS.md` for the full claim boundary.

final_proof/FINAL_RECEIPT_SUMMARY.json

@@ -0,0 +1,380 @@
+{
+  "a_grade_promotion": {
+    "accepted_live_matches": 0,
+    "blocker_codes": [
+      "missing_live_legacy_trace_corpus",
+      "runtime_assets_not_execution_evidence",
+      "no_local_mainframe_or_aws_runtime_path_detected",
+      "static_oracle_is_not_a_grade"
+    ],
+    "current_A": 0,
+    "current_gap_count": 0,
+    "current_grade_counts": {
+      "A": 0,
+      "B": 50,
+      "C": 0,
+      "F": 0
+    },
+    "decision_action": "do_not_promote",
+    "generated_utc": "2026-05-23T15:01:52+00:00",
+    "missing_live_matches": 50,
+    "path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\final_proof\\A_GRADE_PROMOTION_REPORT.json",
+    "promotable_to_A": false,
+    "readme_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\final_proof\\A_GRADE_PROMOTION_README.md",
+    "report_hash": "4f962c34517806cf2dee00f3fdd0b7c4f51e9ec3f5935eedfabd04104e3ad3af",
+    "report_version": "carddemo_a_grade_promotion_gate_v0",
+    "required_live_matches": 50,
+    "target_A": 50,
+    "trace_contract": {
+      "accepted_trace_kinds": [
+        "live_cobol_cics_runtime",
+        "live_mainframe_runtime"
+      ],
+      "field_rules": {
+        "capability_id": "must match one ID in reports/capability_ledger.json",
+        "hash_fields": "64-character SHA-256 hex digests",
+        "matched": true,
+        "source_head": "59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e"
+      },
+      "required_fields": [
+        "capability_id",
+        "trace_kind",
+        "source_head",
+        "legacy_runtime_environment",
+        "modern_observation_hash",
+        "comparator_version",
+        "matched",
+        "raw_legacy_trace_hash or legacy_runtime_trace_hash"
+      ]
+    }
+  },
+  "bundle_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\final_proof",
+  "clean_repro_verification": {
+    "api_smoke": {
+      "batch_resource_setup_tranidx": {
+        "alternate_index": {
+          "cylinders": [
+            5,
+            1
+          ],
+          "data": "AWS.M2.CARDDEMO.TRANSACT.VSAM.AIX.DATA",
+          "index": "AWS.M2.CARDDEMO.TRANSACT.VSAM.AIX.INDEX",
+          "keys": {
+            "length": 26,
+            "offset": 304
+          },
+          "name": "AWS.M2.CARDDEMO.TRANSACT.VSAM.AIX",
+          "nonunique": true,
+          "record_size": [
+            350,
+            350
+          ],
+          "relate": "AWS.M2.CARDDEMO.TRANSACT.VSAM.KSDS",
+          "upgrade": true,
+          "volume": "AWSHJ1"
+        },
+        "bldindex": {
+          "indataset": "AWS.M2.CARDDEMO.TRANSACT.VSAM.KSDS",
+          "outdataset": "AWS.M2.CARDDEMO.TRANSACT.VSAM.AIX",
+          "source_record_count": 300
+        },
+        "function": "Define AIX for transaction file",
+        "legacy_job": "TRANIDX",
+        "legacy_program": "IDCAMS",
+        "path": {
+          "name": "AWS.M2.CARDDEMO.TRANSACT.VSAM.AIX.PATH",
+          "pathentry": "AWS.M2.CARDDEMO.TRANSACT.VSAM.AIX"
+        },
+        "source_oracle": "TRANIDX.jcl DEFINE ALTERNATEINDEX, DEFINE PATH, and BLDINDEX statements",
+        "steps": [
+          {
+            "control": "DEFINE ALTERNATEINDEX",
+            "program": "IDCAMS",
+            "step": "STEP20"
+          },
+          {
+            "control": "DEFINE PATH",
+            "program": "IDCAMS",
+            "step": "STEP25"
+          },
+          {
+            "control": "BLDINDEX",
+            "program": "IDCAMS",
+            "step": "STEP30"
+          }
+        ]
+      },
+      "health": {
+        "source_root": "..\\source",
+        "status": "ok"
+      },
+      "mq_system_date": {
+        "error_queue": "CARD.DEMO.ERROR.QUEUE",
+        "input_queue": "CARD.DEMO.REQUEST.DATE",
+        "legacy_pattern": "MQ request/reply",
+        "legacy_program": "CODATE01",
+        "legacy_transaction": "CDRD",
+        "message_format": {
+          "correlation": "reply reuses MQMD message id and correl id",
+          "mq_format": "MQFMT_STRING",
+          "reply_length": 1000,
+          "request_copy": "REQUEST-MSG-COPY"
+        },
+        "reply_message": "SYSTEM DATE : 05-23-2026SYSTEM TIME : 11:12:13",
+        "reply_queue": "CARD.DEMO.REPLY.DATE",
+        "request_message": "DATE                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ",
+        "source_oracle": "CODATE01 4000-PROCESS-REQUEST-REPLY uses CICS ASKTIME/FORMATTIME MMDDYYYY DATESEP('-') TIMESEP and does not validate WS-FUNC",
+        "system_date": "05-23-2026",
+        "system_time": "11:12:13"
+      },
+      "summary": {
+        "claim_limit": "capability ledger and static-oracle traces only; no all-path COBOL runtime proof yet",
+        "counts": {
+          "accounts": 50,
+          "authorization_frauds": 0,
+          "card_xrefs": 50,
+          "cards": 50,
+          "customers": 50,
+          "disclosure_groups": 51,
+          "pending_authorization_details": 202,
+          "pending_authorization_summaries": 21,
+          "transaction_categories": 18,
+          "transaction_category_balances": 50,
+          "transaction_types": 7,
+          "transactions": 300,
+          "users": 10
+        },
+        "portfolio": {
+          "credit_limit": "233711.00",
+          "current_balance": "12269.00"
+        }
+      }
+    },
+    "api_smoke_passed": true,
+    "commands": [
+      {
+        "command": "C:\\Users\\Cjc00\\AppData\\Local\\Programs\\Python\\Python311\\python.exe -m carddemo.cli init-db --source-root ..\\source --db-path .\\carddemo.sqlite",
+        "cwd": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z\\modern_carddemo",
+        "duration_seconds": 0.781,
+        "name": "setup",
+        "passed": true,
+        "returncode": 0,
+        "stderr_tail": "",
+        "stdout_tail": "{'customers': 50, 'accounts': 50, 'cards': 50, 'card_xrefs': 50, 'transactions': 300, 'transaction_types': 7, 'transaction_categories': 18, 'disclosure_groups': 51, 'transaction_category_balances': 50, 'users': 10, 'pending_authorization_summaries': 21, 'pending_authorization_details': 202}\n"
+      },
+      {
+        "command": "C:\\Users\\Cjc00\\AppData\\Local\\Programs\\Python\\Python311\\python.exe -m unittest discover -s tests",
+        "cwd": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z\\modern_carddemo",
+        "duration_seconds": 21.297,
+        "name": "test",
+        "passed": true,
+        "returncode": 0,
+        "stderr_tail": "..................................................\n----------------------------------------------------------------------\nRan 50 tests in 20.718s\n\nOK\n",
+        "stdout_tail": ""
+      },
+      {
+        "command": "C:\\Users\\Cjc00\\AppData\\Local\\Programs\\Python\\Python311\\python.exe tools\\generate_receipts.py --source-root ..\\source --db-path .\\carddemo.sqlite --out-dir .\\reports",
+        "cwd": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z\\modern_carddemo",
+        "duration_seconds": 0.797,
+        "name": "receipt",
+        "passed": true,
+        "returncode": 0,
+        "stderr_tail": "",
+        "stdout_tail": "{\n  \"receipt\": \"reports\\\\modernization_receipt.json\",\n  \"parity\": \"reports\\\\parity_gap_report.json\",\n  \"passed\": true\n}\n"
+      },
+      {
+        "command": "C:\\Users\\Cjc00\\AppData\\Local\\Programs\\Python\\Python311\\python.exe tools\\replay_static_oracles.py --source-root ..\\source --out-dir .\\reports --source-head 59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e",
+        "cwd": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z\\modern_carddemo",
+        "duration_seconds": 0.516,
+        "name": "static_oracle_replay",
+        "passed": true,
+        "returncode": 0,
+        "stderr_tail": "",
+        "stdout_tail": "{\n  \"replay\": \"reports\\\\static_oracle_replay.json\",\n  \"passed\": true,\n  \"replay_hash\": \"da60110c66ee3b44432933de91afec1ba09dcbc9551f4495933f9eba3779f56e\",\n  \"failed_checks\": [],\n  \"claim_limit\": \"Executable modern replay over static/source-oracle traces only; no live COBOL/CICS runtime replay has been performed.\"\n}\n"
+      },
+      {
+        "command": "C:\\Users\\Cjc00\\AppData\\Local\\Programs\\Python\\Python311\\python.exe tools\\evaluate_a_grade_promotion.py --source-root ..\\source --out-dir .\\final_proof",
+        "cwd": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z\\modern_carddemo",
+        "duration_seconds": 0.234,
+        "name": "a_grade_promotion",
+        "passed": true,
+        "returncode": 0,
+        "stderr_tail": "",
+        "stdout_tail": "{\n  \"accepted_live_matches\": 0,\n  \"current_grade_counts\": {\n    \"A\": 0,\n    \"B\": 50,\n    \"C\": 0,\n    \"F\": 0\n  },\n  \"missing_live_matches\": 50,\n  \"out_dir\": \"D:\\\\scraper_storage\\\\modernization_labs\\\\aws-carddemo-modernization-20260523T073000Z\\\\clean_repro_20260523T150205Z\\\\modern_carddemo\\\\final_proof\",\n  \"promotable_to_A\": false,\n  \"report_hash\": \"88b3cc4916145340ed2dec0135ba25ee1b9ddd4029c7e1e4aedb586643286544\",\n  \"required_live_matches\": 50\n}\n"
+      },
+      {
+        "command": "C:\\Users\\Cjc00\\AppData\\Local\\Programs\\Python\\Python311\\python.exe tools\\build_no_cost_confidence.py --source-root ..\\source --out-dir .\\final_proof",
+        "cwd": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z\\modern_carddemo",
+        "duration_seconds": 0.578,
+        "name": "no_cost_confidence",
+        "passed": true,
+        "returncode": 0,
+        "stderr_tail": "",
+        "stdout_tail": "{\n  \"out_dir\": \"D:\\\\scraper_storage\\\\modernization_labs\\\\aws-carddemo-modernization-20260523T073000Z\\\\clean_repro_20260523T150205Z\\\\modern_carddemo\\\\final_proof\",\n  \"ready_for_pre_runtime_review\": true,\n  \"report_hash\": \"20fd4a66a6fa52e75037c4ca5a6c389f613eefa9fdcc4087c036c6b355145c1a\",\n  \"reviewer_posture\": \"strong_pre_runtime_confidence\",\n  \"status_counts\": {\n    \"pass\": 6,\n    \"warn\": 1\n  }\n}\n"
+      },
+      {
+        "command": "C:\\Users\\Cjc00\\AppData\\Local\\Programs\\Python\\Python311\\python.exe tools\\package_final_proof.py --source-root ..\\source",
+        "cwd": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z\\modern_carddemo",
+        "duration_seconds": 0.313,
+        "name": "package_final_proof",
+        "passed": true,
+        "returncode": 0,
+        "stderr_tail": "",
+        "stdout_tail": "\"report_hash\": \"88b3cc4916145340ed2dec0135ba25ee1b9ddd4029c7e1e4aedb586643286544\",\n    \"report_version\": \"carddemo_a_grade_promotion_gate_v0\",\n    \"required_live_matches\": 50,\n    \"target_A\": 50,\n    \"trace_contract\": {\n      \"accepted_trace_kinds\": [\n        \"live_cobol_cics_runtime\",\n        \"live_mainframe_runtime\"\n      ],\n      \"field_rules\": {\n        \"capability_id\": \"must match one ID in reports/capability_ledger.json\",\n        \"hash_fields\": \"64-character SHA-256 hex digests\",\n        \"matched\": true,\n        \"source_head\": \"59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e\"\n      },\n      \"required_fields\": [\n        \"capability_id\",\n        \"trace_kind\",\n        \"source_head\",\n        \"legacy_runtime_environment\",\n        \"modern_observation_hash\",\n        \"comparator_version\",\n        \"matched\",\n        \"raw_legacy_trace_hash or legacy_runtime_trace_hash\"\n      ]\n    }\n  },\n  \"clean_repro_verification_present\": false,\n  \"files\": [\n    \"FINAL_PROOF_README.md\",\n    \"FINAL_RECEIPT_SUMMARY.json\",\n    \"REPRO_COMMANDS.txt\",\n    \"STATIC_ORACLE_REPLAY_REPORT.json\",\n    \"KNOWN_LIMITS.md\",\n    \"ARTIFACT_MANIFEST.json\"\n  ],\n  \"no_cost_confidence\": {\n    \"a_missing_live_matches\": 50,\n    \"a_promotable\": false,\n    \"capability_count\": 50,\n    \"edge_case_count\": 40,\n    \"generated_utc\": \"2026-05-23T15:02:32+00:00\",\n    \"golden_trace_count\": 34,\n    \"legacy_runtime_claim_made\": false,\n    \"paid_runtime_used\": false,\n    \"path\": \"D:\\\\scraper_storage\\\\modernization_labs\\\\aws-carddemo-modernization-20260523T073000Z\\\\clean_repro_20260523T150205Z\\\\modern_carddemo\\\\final_proof\\\\NO_COST_CONFIDENCE_REPORT.json\",\n    \"readme_path\": \"D:\\\\scraper_storage\\\\modernization_labs\\\\aws-carddemo-modernization-20260523T073000Z\\\\clean_repro_20260523T150205Z\\\\modern_carddemo\\\\final_proof\\\\NO_COST_CONFIDENCE_README.md\",\n    \"ready_for_pre_runtime_review\": true,\n    \"remaining_gap\": \"live legacy COBOL/CICS/VSAM/JCL runtime validation on a real or licensed-compatible runtime\",\n    \"report_hash\": \"20fd4a66a6fa52e75037c4ca5a6c389f613eefa9fdcc4087c036c6b355145c1a\",\n    \"report_version\": \"carddemo_no_cost_confidence_v0\",\n    \"reviewer_posture\": \"strong_pre_runtime_confidence\",\n    \"source_ref_total\": 101,\n    \"static_oracle_ready_count\": 50,\n    \"static_replay_passed\": true\n  },\n  \"out_dir\": \"D:\\\\scraper_storage\\\\modernization_labs\\\\aws-carddemo-modernization-20260523T073000Z\\\\clean_repro_20260523T150205Z\\\\modern_carddemo\\\\final_proof\",\n  \"parity\": {\n    \"B\": 50,\n    \"F\": 0,\n    \"capability_count\": 50,\n    \"gap_count\": 0,\n    \"grade_counts\": {\n      \"A\": 0,\n      \"B\": 50,\n      \"C\": 0,\n      \"F\": 0\n    },\n    \"next_gap_ranking_count\": 0,\n    \"one_for_one_parity_ready\": true,\n    \"parity_hash\": \"677ea1276946f3b2acd1791ad704445c5ecd1d208b8246c4de40b02c773916c4\",\n    \"parity_report_passed\": true,\n    \"proof_grade_meanings\": {\n      \"A\": \"actual legacy runtime trace match\",\n      \"B\": \"static legacy data/copybook oracle match\",\n      \"C\": \"implemented or inferred without strict parity proof\",\n      \"F\": \"discovered capability gap\"\n    },\n    \"rubric\": \"current static/source-oracle rubric\",\n    \"static_oracle_or_better_count\": 50,\n    \"strict_runtime_parity_count\": 0\n  },\n  \"static_oracle_replay\": {\n    \"claim_limit\": \"Executable modern replay over static/source-oracle traces only; no live COBOL/CICS runtime replay has been performed.\",\n    \"evidence_hash\": \"b800ca64245b6229211cc4ace2b7c375f59d6d84afd08d04491c67b2ac50d847\",\n    \"failed_checks\": [],\n    \"passed\": true,\n    \"path\": \"D:\\\\scraper_storage\\\\modernization_labs\\\\aws-carddemo-modernization-20260523T073000Z\\\\clean_repro_20260523T150205Z\\\\modern_carddemo\\\\final_proof\\\\STATIC_ORACLE_REPLAY_REPORT.json\",\n    \"replay_hash\": \"da60110c66ee3b44432933de91afec1ba09dcbc9551f4495933f9eba3779f56e\",\n    \"runtime_probe_count\": 6,\n    \"source_report_path\": \"D:\\\\scraper_storage\\\\modernization_labs\\\\aws-carddemo-modernization-20260523T073000Z\\\\clean_repro_20260523T150205Z\\\\modern_carddemo\\\\reports\\\\static_oracle_replay.json\"\n  }\n}\n"
+      }
+    ],
+    "copied_workspace": {
+      "modern_copy": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z\\modern_carddemo",
+      "scratch_root": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z",
+      "source_copy": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z\\source"
+    },
+    "generated_utc": "2026-05-23T15:02:33+00:00",
+    "passed": true,
+    "server_port": 8091,
+    "server_smoke": {
+      "checks": {
+        "health_ok": true,
+        "mq_date_reply": true,
+        "summary_customers_50": true,
+        "tranidx_key_contract": true
+      },
+      "passed": true,
+      "server_command": "C:\\Users\\Cjc00\\AppData\\Local\\Programs\\Python\\Python311\\python.exe -m carddemo.cli serve --source-root ..\\source --db-path .\\carddemo.sqlite --port 8091",
+      "stderr_log": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z\\modern_carddemo\\server_smoke.err.log",
+      "stdout_log": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\clean_repro_20260523T150205Z\\modern_carddemo\\server_smoke.out.log"
+    },
+    "source_head": "59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e",
+    "verification_version": "carddemo_clean_repro_verification_v0"
+  },
+  "commands": {
+    "a_grade_promotion": "python tools\\evaluate_a_grade_promotion.py --source-root ..\\source --out-dir .\\final_proof",
+    "all_local_proof_no_server": "powershell -NoProfile -Command \"python -m carddemo.cli init-db --source-root ..\\source --db-path .\\carddemo.sqlite; python -m unittest discover -s tests; python tools\\generate_receipts.py --source-root ..\\source --db-path .\\carddemo.sqlite --out-dir .\\reports; python tools\\replay_static_oracles.py --source-root ..\\source --out-dir .\\reports --source-head 59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e; python tools\\evaluate_a_grade_promotion.py --source-root ..\\source --out-dir .\\final_proof; python tools\\build_no_cost_confidence.py --source-root ..\\source --out-dir .\\final_proof; python tools\\package_final_proof.py --source-root ..\\source\"",
+    "no_cost_confidence": "python tools\\build_no_cost_confidence.py --source-root ..\\source --out-dir .\\final_proof",
+    "package_final_proof": "python tools\\package_final_proof.py --source-root ..\\source",
+    "receipt": "python tools\\generate_receipts.py --source-root ..\\source --db-path .\\carddemo.sqlite --out-dir .\\reports",
+    "run": "python -m carddemo.cli serve --source-root ..\\source --db-path .\\carddemo.sqlite --port 8087",
+    "setup": "python -m carddemo.cli init-db --source-root ..\\source --db-path .\\carddemo.sqlite",
+    "static_oracle_replay": "python tools\\replay_static_oracles.py --source-root ..\\source --out-dir .\\reports --source-head 59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e",
+    "test": "python -m unittest discover -s tests"
+  },
+  "generated_utc": "2026-05-23T15:02:34+00:00",
+  "known_limits": [
+    "This proof is static/source-oracle parity plus executable modern-service replay. It is not live COBOL/CICS all-path runtime equivalence.",
+    "A-grade live legacy runtime trace matching remains 0 under the current proof-grade rubric.",
+    "A-grade promotion is gated by A_GRADE_PROMOTION_REPORT.json and requires accepted live legacy runtime traces.",
+    "NO_COST_CONFIDENCE_REPORT.json records maximum unpaid/pre-runtime evidence and the remaining paid/runtime validation boundary.",
+    "The static replay exercises selected trace expectations; it is not exhaustive path coverage.",
+    "The modern app is a local Python/SQLite target and not a production deployment package."
+  ],
+  "modern_code": {
+    "local_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo",
+    "modern_hash_count": 29,
+    "modern_hashes_digest": "599294a7df7226c4d2a4b820de4bf567abbd1bdd1e41a1b6fd123457cb3abf40"
+  },
+  "no_cost_confidence": {
+    "a_missing_live_matches": 50,
+    "a_promotable": false,
+    "capability_count": 50,
+    "edge_case_count": 40,
+    "generated_utc": "2026-05-23T15:02:34+00:00",
+    "golden_trace_count": 34,
+    "legacy_runtime_claim_made": false,
+    "paid_runtime_used": false,
+    "path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\final_proof\\NO_COST_CONFIDENCE_REPORT.json",
+    "readme_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\final_proof\\NO_COST_CONFIDENCE_README.md",
+    "ready_for_pre_runtime_review": true,
+    "remaining_gap": "live legacy COBOL/CICS/VSAM/JCL runtime validation on a real or licensed-compatible runtime",
+    "report_hash": "c72a4b6b30b7bbee9096b3d79e2893fb0263d5aee1f4aebaec37401810208441",
+    "report_version": "carddemo_no_cost_confidence_v0",
+    "reviewer_posture": "strong_pre_runtime_confidence",
+    "source_ref_total": 101,
+    "static_oracle_ready_count": 50,
+    "static_replay_passed": true
+  },
+  "parity": {
+    "B": 50,
+    "F": 0,
+    "capability_count": 50,
+    "gap_count": 0,
+    "grade_counts": {
+      "A": 0,
+      "B": 50,
+      "C": 0,
+      "F": 0
+    },
+    "next_gap_ranking_count": 0,
+    "one_for_one_parity_ready": true,
+    "parity_hash": "eef71685c56f22c2669311d9e2e7f1ce4f0cbe20b6542f405bb3d16cab1da95e",
+    "parity_report_passed": true,
+    "proof_grade_meanings": {
+      "A": "actual legacy runtime trace match",
+      "B": "static legacy data/copybook oracle match",
+      "C": "implemented or inferred without strict parity proof",
+      "F": "discovered capability gap"
+    },
+    "rubric": "current static/source-oracle rubric",
+    "static_oracle_or_better_count": 50,
+    "strict_runtime_parity_count": 0
+  },
+  "public_actions_allowed": false,
+  "receipt": {
+    "generated_utc": "2026-05-23T15:01:51+00:00",
+    "path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\reports\\modernization_receipt.json",
+    "receipt_hash": "fea9dfeca8e1b400afe6fbf4a25f92282a6330da0bb031f87b8dbd6e41044819",
+    "seed_counts": {
+      "accounts": 50,
+      "card_xrefs": 50,
+      "cards": 50,
+      "customers": 50,
+      "disclosure_groups": 51,
+      "pending_authorization_details": 202,
+      "pending_authorization_summaries": 21,
+      "transaction_categories": 18,
+      "transaction_category_balances": 50,
+      "transaction_types": 7,
+      "transactions": 300,
+      "users": 10
+    },
+    "source_head": "59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e"
+  },
+  "smoke_evidence": [
+    {
+      "absolute_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\reports\\ui_batch_reports_smoke.png",
+      "exists": true,
+      "path": "reports/ui_batch_reports_smoke.png",
+      "role": "existing_screenshot",
+      "sha256": "f192f2b751ee902b70defbb5b49b745bbf8855a10bb8dc23d60e6c8bb9f6e537",
+      "size_bytes": 69723
+    },
+    {
+      "endpoints": [
+        "batch_resource_setup_tranidx",
+        "health",
+        "mq_system_date",
+        "summary"
+      ],
+      "passed": true,
+      "port": 8091,
+      "role": "clean_copy_api_smoke"
+    }
+  ],
+  "source": {
+    "head": "59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e",
+    "local_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\source",
+    "repo_url": "https://github.com/aws-samples/aws-mainframe-modernization-carddemo.git",
+    "source_hash_count": 204,
+    "source_hashes_digest": "0703f97553bde0f5bd170aa95ec8c771a975b397be7d9e8088ec6fbf31d333c2",
+    "status_short": ""
+  },
+  "static_oracle_replay": {
+    "claim_limit": "Executable modern replay over static/source-oracle traces only; no live COBOL/CICS runtime replay has been performed.",
+    "evidence_hash": "c661998c6538b8118b5abf4d248cad72dfa138e087bded1a4c37a5e6a7377bab",
+    "failed_checks": [],
+    "passed": true,
+    "path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\final_proof\\STATIC_ORACLE_REPLAY_REPORT.json",
+    "replay_hash": "912e98e11d46cd967070d06ec17aaed3402bed44026267d1906ea6a2d54b9a42",
+    "runtime_probe_count": 6,
+    "source_report_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\reports\\static_oracle_replay.json"
+  },
+  "summary_version": "carddemo_final_proof_summary_v0"
+}

final_proof/KNOWN_LIMITS.md

@@ -0,0 +1,13 @@
+
+# Known Limits
+
+This proof is static/source-oracle parity plus executable modern-service replay. It is not live COBOL/CICS all-path runtime equivalence.
+
+- Proof grade `B` means static legacy data/copybook/source-oracle match. It does not mean the original COBOL/CICS system was executed and compared for every path.
+- Proof grade `A` is reserved for actual legacy runtime trace match; this bundle records `A=0`.
+- `A_GRADE_PROMOTION_REPORT.json` is the executable promotion gate. It fails closed unless accepted live legacy runtime trace records exist for every capability.
+- `NO_COST_CONFIDENCE_REPORT.json` records maximum unpaid/pre-runtime evidence. It is designed to support review confidence, not to replace live legacy validation.
+- The replay report executes the modern Python service against extracted static/source-oracle expectations. It is useful evidence, but not exhaustive path coverage.
+- The source data and copybooks are from AWS CardDemo at the pinned source version in `FINAL_RECEIPT_SUMMARY.json`.
+- The app is a local Python/SQLite modernization target. Production concerns such as deployment topology, operations, security hardening, and load testing are outside this proof bundle.
+- Public release, upload, or promotion is intentionally not performed by this bundle.

final_proof/NO_COST_CONFIDENCE_README.md

@@ -0,0 +1,41 @@
+# AWS CardDemo No-Cost Confidence Proof
+
+Report version: `carddemo_no_cost_confidence_readme_v0`
+
+This artifact answers the practical question: how far did we get without paying for or depending on a licensed legacy runtime?
+
+## Result
+
+- Reviewer posture: `strong_pre_runtime_confidence`
+- Ready for pre-runtime review: `True`
+- Paid runtime used: `False`
+- Public actions allowed: `False`
+- Remaining gap: `live legacy COBOL/CICS/VSAM/JCL runtime validation on a real or licensed-compatible runtime`
+
+## Evidence We Can Produce For Free
+
+- Capability coverage: `50` capabilities.
+- Static/source-oracle ready: `50` capabilities.
+- Source references attached to capability ledger: `101`.
+- Static replay passed: `True`.
+- Static replay hash: `912e98e11d46cd967070d06ec17aaed3402bed44026267d1906ea6a2d54b9a42`.
+- Golden traces: `34`.
+- Edge cases: `40`.
+- Clean-copy/API smoke evidence is recorded in `FINAL_RECEIPT_SUMMARY.json`.
+
+## Legacy Source Runtime Shape
+
+- COBOL programs scanned: `44`.
+- CICS programs: `25`.
+- Non-CICS COBOL programs: `19`.
+- Free GnuCOBOL probe candidates: `17`.
+- Programs still requiring mainframe-compatible runtime for honest execution: `27`.
+
+## A-Grade Boundary
+
+- A-grade decision: `do_not_promote`.
+- Promotable to A: `False`.
+- Accepted live runtime matches: `0`.
+- Missing live runtime matches: `50`.
+
+This does not pretend to be live COBOL/CICS equivalence. It shows that the unpaid work is strong and that the remaining proof step is specifically live legacy runtime validation.

final_proof/NO_COST_CONFIDENCE_REPORT.json

@@ -0,0 +1,932 @@
+{
+  "a_grade_gate": {
+    "accepted_live_matches": 0,
+    "decision": "do_not_promote",
+    "missing_live_matches": 50,
+    "present": true,
+    "promotable_to_A": false,
+    "report_hash": "4f962c34517806cf2dee00f3fdd0b7c4f51e9ec3f5935eedfabd04104e3ad3af",
+    "required_live_matches": 50
+  },
+  "capability_coverage": {
+    "all_have_source_refs": true,
+    "all_static_oracle_ready": true,
+    "capability_count": 50,
+    "proof_grade_counts": {
+      "B": 50
+    },
+    "source_ref_max": 3,
+    "source_ref_min": 1,
+    "source_ref_total": 101,
+    "static_oracle_ready_count": 50,
+    "strict_runtime_ready_count": 0,
+    "surface_counts": {
+      "batch": 26,
+      "online": 24
+    },
+    "zero_source_ref_capability_ids": []
+  },
+  "claim_boundary": "Maximum no-cost confidence evidence only. This is not live COBOL/CICS all-path runtime equivalence.",
+  "fixture_corpus": {
+    "edge_case_count": 40,
+    "edge_case_hash": "505e3dd03fad7208896802f1a160d32514ce6b7a0f59d2d3947f21b81d6d8fb5",
+    "golden_trace_count": 34,
+    "golden_trace_hash": "0acaa652f42e6faba2fec61ec9836d7c2fbf0ded5cbda40cf479c38ea2812f01"
+  },
+  "generated_utc": "2026-05-23T15:02:34+00:00",
+  "legacy_source_semantics_scan": {
+    "cics_program_count": 25,
+    "cobol_program_count": 44,
+    "free_gnucobol_probe_candidate_count": 17,
+    "free_gnucobol_probe_candidate_paths": [
+      "app/app-authorization-ims-db2-mq/cbl/DBUNLDGS.CBL",
+      "app/app-authorization-ims-db2-mq/cbl/PAUDBLOD.CBL",
+      "app/app-authorization-ims-db2-mq/cbl/PAUDBUNL.CBL",
+      "app/cbl/CBACT01C.cbl",
+      "app/cbl/CBACT02C.cbl",
+      "app/cbl/CBACT03C.cbl",
+      "app/cbl/CBACT04C.cbl",
+      "app/cbl/CBCUS01C.cbl",
+      "app/cbl/CBEXPORT.cbl",
+      "app/cbl/CBIMPORT.cbl",
+      "app/cbl/CBSTM03A.CBL",
+      "app/cbl/CBSTM03B.CBL",
+      "app/cbl/CBTRN01C.cbl",
+      "app/cbl/CBTRN02C.cbl",
+      "app/cbl/CBTRN03C.cbl",
+      "app/cbl/COBSWAIT.cbl",
+      "app/cbl/CSUTLDTC.cbl"
+    ],
+    "non_cics_cobol_count": 19,
+    "programs": [
+      {
+        "cics_operation_hints": [],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": false,
+        "has_dli": true,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 386,
+        "path": "app/app-authorization-ims-db2-mq/cbl/CBPAUP0C.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "READ",
+          "RETURN",
+          "SEND",
+          "WRITE"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": true,
+        "has_file_io": true,
+        "has_mq_hint": true,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 1026,
+        "path": "app/app-authorization-ims-db2-mq/cbl/COPAUA0C.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "READ",
+          "RECEIVE",
+          "RETURN",
+          "SEND",
+          "XCTL"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": true,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 1032,
+        "path": "app/app-authorization-ims-db2-mq/cbl/COPAUS0C.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "LINK",
+          "READ",
+          "RECEIVE",
+          "RETURN",
+          "SEND",
+          "XCTL"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": true,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 604,
+        "path": "app/app-authorization-ims-db2-mq/cbl/COPAUS1C.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "RETURN"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": false,
+        "has_file_io": false,
+        "has_mq_hint": false,
+        "has_sql": true,
+        "has_vsam_shape": false,
+        "line_count": 244,
+        "path": "app/app-authorization-ims-db2-mq/cbl/COPAUS2C.cbl"
+      },
+      {
+        "cics_operation_hints": [],
+        "free_compile_feasibility": "possible_isolated_gnucobol_probe",
+        "has_cics": false,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": true,
+        "line_count": 366,
+        "path": "app/app-authorization-ims-db2-mq/cbl/DBUNLDGS.CBL"
+      },
+      {
+        "cics_operation_hints": [],
+        "free_compile_feasibility": "possible_isolated_gnucobol_probe",
+        "has_cics": false,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": true,
+        "line_count": 369,
+        "path": "app/app-authorization-ims-db2-mq/cbl/PAUDBLOD.CBL"
+      },
+      {
+        "cics_operation_hints": [],
+        "free_compile_feasibility": "possible_isolated_gnucobol_probe",
+        "has_cics": false,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": true,
+        "line_count": 317,
+        "path": "app/app-authorization-ims-db2-mq/cbl/PAUDBUNL.CBL"
+      },
+      {
+        "cics_operation_hints": [],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": false,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": true,
+        "has_vsam_shape": true,
+        "line_count": 237,
+        "path": "app/app-transaction-type-db2/cbl/COBTUPDT.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "DELETE",
+          "READ",
+          "RECEIVE",
+          "RETURN",
+          "SEND",
+          "XCTL"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": true,
+        "has_vsam_shape": false,
+        "line_count": 2098,
+        "path": "app/app-transaction-type-db2/cbl/COTRTLIC.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "DELETE",
+          "READ",
+          "RECEIVE",
+          "RETURN",
+          "SEND",
+          "WRITE",
+          "XCTL"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": true,
+        "has_vsam_shape": false,
+        "line_count": 1702,
+        "path": "app/app-transaction-type-db2/cbl/COTRTUPC.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "READ",
+          "RETURN",
+          "SEND"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": true,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 620,
+        "path": "app/app-vsam-mq/cbl/COACCT01.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "RETURN"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": false,
+        "has_file_io": false,
+        "has_mq_hint": true,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 524,
+        "path": "app/app-vsam-mq/cbl/CODATE01.cbl"
+      },
+      {
+        "cics_operation_hints": [],
+        "free_compile_feasibility": "possible_isolated_gnucobol_probe",
+        "has_cics": false,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": true,
+        "line_count": 430,
+        "path": "app/cbl/CBACT01C.cbl"
+      },
+      {
+        "cics_operation_hints": [],
+        "free_compile_feasibility": "possible_isolated_gnucobol_probe",
+        "has_cics": false,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": true,
+        "line_count": 178,
+        "path": "app/cbl/CBACT02C.cbl"
+      },
+      {
+        "cics_operation_hints": [],
+        "free_compile_feasibility": "possible_isolated_gnucobol_probe",
+        "has_cics": false,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": true,
+        "line_count": 178,
+        "path": "app/cbl/CBACT03C.cbl"
+      },
+      {
+        "cics_operation_hints": [],
+        "free_compile_feasibility": "possible_isolated_gnucobol_probe",
+        "has_cics": false,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": true,
+        "line_count": 652,
+        "path": "app/cbl/CBACT04C.cbl"
+      },
+      {
+        "cics_operation_hints": [],
+        "free_compile_feasibility": "possible_isolated_gnucobol_probe",
+        "has_cics": false,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": true,
+        "line_count": 178,
+        "path": "app/cbl/CBCUS01C.cbl"
+      },
+      {
+        "cics_operation_hints": [],
+        "free_compile_feasibility": "possible_isolated_gnucobol_probe",
+        "has_cics": false,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": true,
+        "line_count": 582,
+        "path": "app/cbl/CBEXPORT.cbl"
+      },
+      {
+        "cics_operation_hints": [],
+        "free_compile_feasibility": "possible_isolated_gnucobol_probe",
+        "has_cics": false,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": true,
+        "line_count": 487,
+        "path": "app/cbl/CBIMPORT.cbl"
+      },
+      {
+        "cics_operation_hints": [],
+        "free_compile_feasibility": "possible_isolated_gnucobol_probe",
+        "has_cics": false,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 924,
+        "path": "app/cbl/CBSTM03A.CBL"
+      },
+      {
+        "cics_operation_hints": [],
+        "free_compile_feasibility": "possible_isolated_gnucobol_probe",
+        "has_cics": false,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": true,
+        "line_count": 230,
+        "path": "app/cbl/CBSTM03B.CBL"
+      },
+      {
+        "cics_operation_hints": [],
+        "free_compile_feasibility": "possible_isolated_gnucobol_probe",
+        "has_cics": false,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": true,
+        "line_count": 494,
+        "path": "app/cbl/CBTRN01C.cbl"
+      },
+      {
+        "cics_operation_hints": [],
+        "free_compile_feasibility": "possible_isolated_gnucobol_probe",
+        "has_cics": false,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": true,
+        "line_count": 731,
+        "path": "app/cbl/CBTRN02C.cbl"
+      },
+      {
+        "cics_operation_hints": [],
+        "free_compile_feasibility": "possible_isolated_gnucobol_probe",
+        "has_cics": false,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": true,
+        "line_count": 649,
+        "path": "app/cbl/CBTRN03C.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "READ",
+          "RECEIVE",
+          "RETURN",
+          "REWRITE",
+          "SEND",
+          "WRITE",
+          "XCTL"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 4236,
+        "path": "app/cbl/COACTUPC.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "READ",
+          "RECEIVE",
+          "RETURN",
+          "SEND",
+          "XCTL"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 941,
+        "path": "app/cbl/COACTVWC.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "RECEIVE",
+          "RETURN",
+          "SEND",
+          "XCTL"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": false,
+        "has_file_io": false,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 288,
+        "path": "app/cbl/COADM01C.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "ENDBR",
+          "READ",
+          "RECEIVE",
+          "RETURN",
+          "REWRITE",
+          "SEND",
+          "STARTBR",
+          "WRITE",
+          "XCTL"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 572,
+        "path": "app/cbl/COBIL00C.cbl"
+      },
+      {
+        "cics_operation_hints": [],
+        "free_compile_feasibility": "possible_isolated_gnucobol_probe",
+        "has_cics": false,
+        "has_dli": false,
+        "has_file_io": false,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 41,
+        "path": "app/cbl/COBSWAIT.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "ENDBR",
+          "READ",
+          "READNEXT",
+          "RECEIVE",
+          "RETURN",
+          "SEND",
+          "STARTBR",
+          "XCTL"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 1459,
+        "path": "app/cbl/COCRDLIC.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "READ",
+          "RECEIVE",
+          "RETURN",
+          "SEND",
+          "XCTL"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 887,
+        "path": "app/cbl/COCRDSLC.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "READ",
+          "RECEIVE",
+          "RETURN",
+          "REWRITE",
+          "SEND",
+          "WRITE",
+          "XCTL"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 1560,
+        "path": "app/cbl/COCRDUPC.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "RECEIVE",
+          "RETURN",
+          "SEND",
+          "XCTL"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": false,
+        "has_file_io": false,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 308,
+        "path": "app/cbl/COMEN01C.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "RECEIVE",
+          "RETURN",
+          "SEND",
+          "WRITE",
+          "XCTL"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 649,
+        "path": "app/cbl/CORPT00C.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "READ",
+          "RECEIVE",
+          "RETURN",
+          "SEND",
+          "XCTL"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 260,
+        "path": "app/cbl/COSGN00C.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "ENDBR",
+          "READNEXT",
+          "RECEIVE",
+          "RETURN",
+          "SEND",
+          "STARTBR",
+          "XCTL"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": false,
+        "has_file_io": false,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 699,
+        "path": "app/cbl/COTRN00C.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "READ",
+          "RECEIVE",
+          "RETURN",
+          "SEND",
+          "XCTL"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 330,
+        "path": "app/cbl/COTRN01C.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "ENDBR",
+          "READ",
+          "RECEIVE",
+          "RETURN",
+          "SEND",
+          "STARTBR",
+          "WRITE",
+          "XCTL"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 783,
+        "path": "app/cbl/COTRN02C.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "ENDBR",
+          "READNEXT",
+          "RECEIVE",
+          "RETURN",
+          "SEND",
+          "STARTBR",
+          "XCTL"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": false,
+        "has_file_io": false,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 695,
+        "path": "app/cbl/COUSR00C.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "RECEIVE",
+          "RETURN",
+          "SEND",
+          "WRITE",
+          "XCTL"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 299,
+        "path": "app/cbl/COUSR01C.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "READ",
+          "RECEIVE",
+          "RETURN",
+          "REWRITE",
+          "SEND",
+          "XCTL"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 414,
+        "path": "app/cbl/COUSR02C.cbl"
+      },
+      {
+        "cics_operation_hints": [
+          "DELETE",
+          "READ",
+          "RECEIVE",
+          "RETURN",
+          "SEND",
+          "XCTL"
+        ],
+        "free_compile_feasibility": "requires_mainframe_or_compatible_runtime",
+        "has_cics": true,
+        "has_dli": false,
+        "has_file_io": true,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 359,
+        "path": "app/cbl/COUSR03C.cbl"
+      },
+      {
+        "cics_operation_hints": [],
+        "free_compile_feasibility": "possible_isolated_gnucobol_probe",
+        "has_cics": false,
+        "has_dli": false,
+        "has_file_io": false,
+        "has_mq_hint": false,
+        "has_sql": false,
+        "has_vsam_shape": false,
+        "line_count": 157,
+        "path": "app/cbl/CSUTLDTC.cbl"
+      }
+    ],
+    "runtime_required_program_count": 27
+  },
+  "local_runtime_feasibility": {
+    "conclusion": "Free/local analysis can inspect, parse, hash, replay extracted expectations, and optionally probe isolated non-CICS COBOL if cobc is available. It cannot honestly replace CICS/VSAM/JCL execution.",
+    "tooling_probe": {
+      "aws": {
+        "path": null,
+        "present": false,
+        "tool": "aws",
+        "why_checked": "AWS runtime path probe; not required for no-cost proof and not used here."
+      },
+      "cobc": {
+        "path": null,
+        "present": false,
+        "tool": "cobc",
+        "why_checked": "Free COBOL compiler probe for isolated non-CICS COBOL logic."
+      },
+      "docker": {
+        "path": "C:\\Program Files\\Docker\\Docker\\resources\\bin\\docker.EXE",
+        "present": true,
+        "tool": "docker",
+        "version_probe_ok": true,
+        "version_probe_output": "\"29.1.2\"",
+        "version_probe_returncode": 0,
+        "why_checked": "Container runtime probe; useful only if a runnable legacy runtime image is available."
+      },
+      "gradle": {
+        "path": null,
+        "present": false,
+        "tool": "gradle",
+        "why_checked": "Gradle probe for Java tooling."
+      },
+      "hercules": {
+        "path": null,
+        "present": false,
+        "tool": "hercules",
+        "why_checked": "Mainframe emulator probe; not sufficient by itself for CICS/VSAM/JCL."
+      },
+      "java": {
+        "path": null,
+        "present": false,
+        "tool": "java",
+        "why_checked": "JVM probe for possible migration/runtime tools."
+      },
+      "mvn": {
+        "path": null,
+        "present": false,
+        "tool": "mvn",
+        "why_checked": "Maven probe for Java tooling."
+      },
+      "tn3270": {
+        "path": null,
+        "present": false,
+        "tool": "tn3270",
+        "why_checked": "3270 terminal probe for live CICS transaction capture."
+      }
+    }
+  },
+  "modern_code": {
+    "local_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo"
+  },
+  "no_cost_confidence_layers": [
+    {
+      "detail": "source_head=59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e source_hash_count=204",
+      "layer": "source_identity_and_hashes",
+      "status": "pass"
+    },
+    {
+      "detail": "capabilities=50 B=50 gaps=0",
+      "layer": "one_for_one_capability_ledger",
+      "status": "pass"
+    },
+    {
+      "detail": "source_refs=101 static_ready=50",
+      "layer": "source_reference_coverage",
+      "status": "pass"
+    },
+    {
+      "detail": "runtime_probe_count=6 failed_checks=0",
+      "layer": "executable_static_oracle_replay",
+      "status": "pass"
+    },
+    {
+      "detail": "edge_cases=40 golden_traces=34",
+      "layer": "edge_case_and_golden_trace_corpus",
+      "status": "pass"
+    },
+    {
+      "detail": "clean_repro=True api_smoke=True",
+      "layer": "clean_copy_reproduction_and_api_smoke",
+      "status": "pass"
+    },
+    {
+      "detail": "promotable_to_A=False accepted_live=0 missing_live=50",
+      "layer": "honest_a_grade_runtime_gate",
+      "status": "pass"
+    }
+  ],
+  "no_cost_confidence_summary": {
+    "plain_english": "The modern app is strongly supported by source-derived static oracles, executable modern replay, edge cases, clean-copy tests, and API smoke. A reviewer should still require live legacy runtime validation before accepting production equivalence.",
+    "ready_for_pre_runtime_review": true,
+    "remaining_gap": "live legacy COBOL/CICS/VSAM/JCL runtime validation on a real or licensed-compatible runtime",
+    "reviewer_posture": "strong_pre_runtime_confidence",
+    "status_counts": {
+      "pass": 7
+    }
+  },
+  "no_cost_scope": {
+    "goal": "Produce the strongest practical pre-runtime evidence without paid/licensed legacy infrastructure, then leave only live legacy runtime validation as the named residual gap.",
+    "legacy_runtime_claim_made": false,
+    "paid_runtime_used": false,
+    "public_actions_allowed": false
+  },
+  "public_actions_allowed": false,
+  "report_hash": "c72a4b6b30b7bbee9096b3d79e2893fb0263d5aee1f4aebaec37401810208441",
+  "report_version": "carddemo_no_cost_confidence_v0",
+  "reviewer_language": {
+    "what_this_cannot_claim": [
+      "It cannot claim all-path live COBOL/CICS equivalence.",
+      "It cannot prove CICS, VSAM, JCL, DB2, IMS, MQ, or terminal behavior that only appears in a paid or hosted runtime.",
+      "It cannot remove the need for final validation in the customer's legacy runtime environment."
+    ],
+    "what_this_should_convince": [
+      "The modernization has a pinned source identity and hashed evidence base.",
+      "Every tracked capability has source-backed static/source-oracle coverage.",
+      "The modern service executes against legacy-derived fixtures without current gaps.",
+      "The remaining risk is specifically runtime-environment validation, not a known missing feature in the current rubric."
+    ]
+  },
+  "source": {
+    "head": "59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e",
+    "local_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\source",
+    "repo_url": "https://github.com/aws-samples/aws-mainframe-modernization-carddemo.git"
+  },
+  "source_inventory": {
+    "app_root": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\source\\app",
+    "evidence_file_count": 184,
+    "evidence_file_hash_digest": "826c7838bf339294bbf185f7d0e8bd2bc970ae34a97bef74ce56ba954590d031",
+    "extension_counts": {
+      ".asm": 2,
+      ".bms": 21,
+      ".ca7": 1,
+      ".cbl": 44,
+      ".controlm": 1,
+      ".cpy": 62,
+      ".csd": 4,
+      ".ctl": 8,
+      ".dat": 1,
+      ".dbd": 4,
+      ".dcl": 3,
+      ".ddl": 6,
+      ".init": 1,
+      ".jcl": 46,
+      ".mac": 2,
+      ".md": 3,
+      ".prc": 2,
+      ".ps": 12,
+      ".psb": 4,
+      ".txt": 10,
+      "<none>": 3
+    },
+    "file_count": 240
+  },
+  "static_oracle_replay": {
+    "claim_limit": "Executable modern replay over static/source-oracle traces only; no live COBOL/CICS runtime replay has been performed.",
+    "evidence_hash": "c661998c6538b8118b5abf4d248cad72dfa138e087bded1a4c37a5e6a7377bab",
+    "failed_checks": [],
+    "passed": true,
+    "present": true,
+    "replay_hash": "912e98e11d46cd967070d06ec17aaed3402bed44026267d1906ea6a2d54b9a42",
+    "runtime_probe_count": 6
+  },
+  "test_and_smoke_evidence": {
+    "api_smoke_passed": true,
+    "clean_repro_passed": true,
+    "clean_repro_present": true,
+    "final_summary_present": true,
+    "screenshot_present": true,
+    "screenshot_sha256": "f192f2b751ee902b70defbb5b49b745bbf8855a10bb8dc23d60e6c8bb9f6e537"
+  }
+}

final_proof/REPRO_COMMANDS.txt

@@ -0,0 +1,41 @@
+
+Run from the modern code root. The source clone/copy must be at ..\source.
+
+SOURCE REPO:
+https://github.com/aws-samples/aws-mainframe-modernization-carddemo.git
+
+SOURCE HEAD:
+59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e
+
+MODERN CODE:
+D:\scraper_storage\modernization_labs\aws-carddemo-modernization-20260523T073000Z\modern_carddemo
+
+SETUP:
+python -m carddemo.cli init-db --source-root ..\source --db-path .\carddemo.sqlite
+
+RUN SERVER:
+python -m carddemo.cli serve --source-root ..\source --db-path .\carddemo.sqlite --port 8087
+
+TEST:
+python -m unittest discover -s tests
+
+STATIC ORACLE REPLAY:
+python tools\replay_static_oracles.py --source-root ..\source --out-dir .\reports --source-head 59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e
+
+A-GRADE PROMOTION GATE:
+python tools\evaluate_a_grade_promotion.py --source-root ..\source --out-dir .\final_proof
+
+NO-COST CONFIDENCE PROOF:
+python tools\build_no_cost_confidence.py --source-root ..\source --out-dir .\final_proof
+
+REGENERATE RECEIPTS:
+python tools\generate_receipts.py --source-root ..\source --db-path .\carddemo.sqlite --out-dir .\reports
+
+PACKAGE FINAL PROOF:
+python tools\package_final_proof.py --source-root ..\source
+
+FULL LOCAL PROOF REFRESH WITHOUT SERVER:
+powershell -NoProfile -Command "python -m carddemo.cli init-db --source-root ..\source --db-path .\carddemo.sqlite; python -m unittest discover -s tests; python tools\generate_receipts.py --source-root ..\source --db-path .\carddemo.sqlite --out-dir .\reports; python tools\replay_static_oracles.py --source-root ..\source --out-dir .\reports --source-head 59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e; python tools\evaluate_a_grade_promotion.py --source-root ..\source --out-dir .\final_proof; python tools\build_no_cost_confidence.py --source-root ..\source --out-dir .\final_proof; python tools\package_final_proof.py --source-root ..\source"
+
+CAVEAT:
+This proof is static/source-oracle parity plus executable modern-service replay. It is not live COBOL/CICS all-path runtime equivalence.

final_proof/STATIC_ORACLE_REPLAY_REPORT.json

@@ -0,0 +1,573 @@
+{
+  "capability_count": 50,
+  "checks": [
+    {
+      "actual": {
+        "accounts": 50,
+        "card_xrefs": 50,
+        "cards": 50,
+        "customers": 50,
+        "disclosure_groups": 51,
+        "pending_authorization_details": 202,
+        "pending_authorization_summaries": 21,
+        "transaction_categories": 18,
+        "transaction_category_balances": 50,
+        "transaction_types": 7,
+        "transactions": 300,
+        "users": 10
+      },
+      "check": "legacy_seed_count_contract",
+      "expected": {
+        "accounts": 50,
+        "card_xrefs": 50,
+        "cards": 50,
+        "customers": 50,
+        "disclosure_groups": 51,
+        "pending_authorization_details": 202,
+        "pending_authorization_summaries": 21,
+        "transaction_categories": 18,
+        "transaction_category_balances": 50,
+        "transaction_types": 7,
+        "transactions": 300,
+        "users": 10
+      },
+      "passed": true
+    },
+    {
+      "actual": 0,
+      "check": "zero_capability_gaps",
+      "expected": 0,
+      "passed": true
+    },
+    {
+      "actual": [],
+      "check": "empty_next_gap_ranking",
+      "expected": [],
+      "passed": true
+    },
+    {
+      "actual": 50,
+      "check": "all_capabilities_static_oracle_or_better",
+      "expected": 50,
+      "passed": true
+    },
+    {
+      "actual": 0,
+      "check": "no_partial_or_inferred_capabilities",
+      "expected": 0,
+      "passed": true
+    },
+    {
+      "actual": [
+        "batch_resource_setup_gdg_vsam_aix_cics",
+        "mq_account_inquiry_cdra_success_and_invalid",
+        "mq_system_date_cdrd_reply",
+        "pending_authorization_cp00_request_response_and_insert",
+        "pending_authorization_cpvs_summary_page",
+        "transaction_type_lookup"
+      ],
+      "check": "required_static_oracle_traces_present",
+      "details": {
+        "missing": []
+      },
+      "expected": [
+        "batch_resource_setup_gdg_vsam_aix_cics",
+        "mq_account_inquiry_cdra_success_and_invalid",
+        "mq_system_date_cdrd_reply",
+        "pending_authorization_cp00_request_response_and_insert",
+        "pending_authorization_cpvs_summary_page",
+        "transaction_type_lookup"
+      ],
+      "passed": true
+    },
+    {
+      "actual": [
+        "authorization_available_credit_boundary",
+        "batch_gdg_limit_scratch_first_generation",
+        "cics_file_control_command_set",
+        "mq_cdra_inqa_account_key_validation",
+        "mq_cdrd_request_payload_ignored",
+        "pending_authorization_ims_segment_header_offset",
+        "transaction_aix_processed_timestamp_key",
+        "vsam_esds_rrds_user_security_layout"
+      ],
+      "check": "required_edge_cases_present",
+      "details": {
+        "missing": []
+      },
+      "expected": [
+        "authorization_available_credit_boundary",
+        "batch_gdg_limit_scratch_first_generation",
+        "cics_file_control_command_set",
+        "mq_cdra_inqa_account_key_validation",
+        "mq_cdrd_request_payload_ignored",
+        "pending_authorization_ims_segment_header_offset",
+        "transaction_aix_processed_timestamp_key",
+        "vsam_esds_rrds_user_security_layout"
+      ],
+      "passed": true
+    },
+    {
+      "actual": {
+        "account_1_recent_transactions": "B",
+        "account_bundle_1": "B",
+        "account_statement_1": "B",
+        "account_update_caup_validated_rewrite": "B",
+        "admin_menu_options": "B",
+        "batch_resource_setup_gdg_vsam_aix_cics": "B",
+        "batch_transaction_type_mnttrdb2_fixed_record_flow": "B",
+        "bill_payment_full_balance": "B",
+        "card_detail_ccdl_account_1": "B",
+        "card_update_ccup_validated_rewrite": "B",
+        "combined_transactions_seed_plus_interest_preview": "B",
+        "customer_search_kessler": "B",
+        "db2_reference_creadb21_schema_and_load": "B",
+        "interest_projection_seed_tcatbal_discgrp": "B",
+        "mq_account_inquiry_cdra_success_and_invalid": "B",
+        "mq_system_date_cdrd_reply": "B",
+        "pending_authorization_cp00_request_response_and_insert": "B",
+        "pending_authorization_cpvd_detail_lookup": "B",
+        "pending_authorization_cpvd_fraud_and_cbpaup0j_purge": "B",
+        "pending_authorization_cpvs_summary_page": "B",
+        "posttran_accept_updates_account_and_tcatbal": "B",
+        "posttran_reject_codes": "B",
+        "regular_main_menu_options": "B",
+        "signon_admin_success": "B",
+        "signon_bad_password_message": "B",
+        "summary_seed_counts": "B",
+        "transaction_add_ct02_validated_write": "B",
+        "transaction_master_tranbkp_backup_redefine": "B",
+        "transaction_report_account_1": "B",
+        "transaction_type_cttu_validated_upsert_delete": "B",
+        "transaction_type_lookup": "B",
+        "transaction_type_tranextr_reference_extract": "B",
+        "user_maintenance_add_update_delete": "B",
+        "user_security_decode": "B"
+      },
+      "check": "all_golden_traces_static_oracle_or_better",
+      "passed": true
+    },
+    {
+      "actual": {
+        "legacy_program": "CODATE01",
+        "legacy_transaction": "CDRD",
+        "reply_message": "SYSTEM DATE : 05-23-2026SYSTEM TIME : 11:12:13",
+        "reply_queue": "CARD.DEMO.REPLY.DATE",
+        "request_payload_validated": false,
+        "system_date": "05-23-2026",
+        "system_time": "11:12:13"
+      },
+      "check": "mq_system_date_cdrd_reply_runtime_probe",
+      "expected": {
+        "legacy_program": "CODATE01",
+        "legacy_transaction": "CDRD",
+        "reply_message": "SYSTEM DATE : 05-23-2026SYSTEM TIME : 11:12:13",
+        "reply_queue": "CARD.DEMO.REPLY.DATE",
+        "request_payload_validated": false,
+        "system_date": "05-23-2026",
+        "system_time": "11:12:13"
+      },
+      "passed": true
+    },
+    {
+      "actual": {
+        "account_id": 1,
+        "active_status": "Y",
+        "bad_function_reply": "INVALID REQUEST PARAMETERS ACCT ID : 00000000001FUNCTION : BAD ",
+        "legacy_program": "COACCT01",
+        "legacy_transaction": "CDRA",
+        "not_found_reply": "INVALID REQUEST PARAMETERS ACCT ID : 99999999999",
+        "reply_has_account_label": true,
+        "reply_queue": "CARD.DEMO.REPLY.ACCT",
+        "request_account_key": "00000000001"
+      },
+      "check": "mq_account_inquiry_cdra_success_and_invalid_runtime_probe",
+      "expected": {
+        "account_id": 1,
+        "active_status": "Y",
+        "bad_function_reply": "INVALID REQUEST PARAMETERS ACCT ID : 00000000001FUNCTION : BAD ",
+        "legacy_program": "COACCT01",
+        "legacy_transaction": "CDRA",
+        "not_found_reply": "INVALID REQUEST PARAMETERS ACCT ID : 99999999999",
+        "reply_has_account_label": true,
+        "reply_queue": "CARD.DEMO.REPLY.ACCT",
+        "request_account_key": "00000000001"
+      },
+      "passed": true
+    },
+    {
+      "actual": {
+        "base_gdg_names": [
+          "AWS.M2.CARDDEMO.TRANSACT.BKUP",
+          "AWS.M2.CARDDEMO.TRANSACT.DALY",
+          "AWS.M2.CARDDEMO.TRANREPT",
+          "AWS.M2.CARDDEMO.TCATBALF.BKUP",
+          "AWS.M2.CARDDEMO.SYSTRAN",
+          "AWS.M2.CARDDEMO.TRANSACT.COMBINED"
+        ],
+        "close_code": "CLO",
+        "db2_first_generation_counts": [
+          7,
+          18,
+          51
+        ],
+        "esds_rrds_organizations": [
+          "NONINDEXED",
+          "NUMBERED"
+        ],
+        "file_sets_match": true,
+        "open_code": "OPE",
+        "resource_count": 6,
+        "tranidx_keys": {
+          "length": 26,
+          "offset": 304
+        },
+        "tranidx_source_count": 300
+      },
+      "check": "batch_resource_setup_gdg_vsam_aix_cics_runtime_probe",
+      "expected": {
+        "base_gdg_names": [
+          "AWS.M2.CARDDEMO.TRANSACT.BKUP",
+          "AWS.M2.CARDDEMO.TRANSACT.DALY",
+          "AWS.M2.CARDDEMO.TRANREPT",
+          "AWS.M2.CARDDEMO.TCATBALF.BKUP",
+          "AWS.M2.CARDDEMO.SYSTRAN",
+          "AWS.M2.CARDDEMO.TRANSACT.COMBINED"
+        ],
+        "close_code": "CLO",
+        "db2_first_generation_counts": [
+          7,
+          18,
+          51
+        ],
+        "esds_rrds_organizations": [
+          "NONINDEXED",
+          "NUMBERED"
+        ],
+        "file_sets_match": true,
+        "open_code": "OPE",
+        "resource_count": 6,
+        "tranidx_keys": {
+          "length": 26,
+          "offset": 304
+        },
+        "tranidx_source_count": 300
+      },
+      "passed": true
+    },
+    {
+      "actual": {
+        "first_transaction_id": "960b9b5480d045a",
+        "next_page": true,
+        "returned_authorizations": 5,
+        "summary_amount_cents": 944,
+        "summary_count": 6
+      },
+      "check": "pending_authorization_cpvs_summary_page_runtime_probe",
+      "expected": {
+        "first_transaction_id": "960b9b5480d045a",
+        "next_page": true,
+        "returned_authorizations": 5,
+        "summary_amount_cents": 944,
+        "summary_count": 6
+      },
+      "passed": true
+    },
+    {
+      "actual": {
+        "backward_page_type_codes": [
+          "04",
+          "05",
+          "06"
+        ],
+        "category_count": 18,
+        "description_filter_count": 1,
+        "legacy_program": "COTRTLIC",
+        "legacy_transaction": "CTLI",
+        "page_size": 7,
+        "type_count": 7,
+        "type_filter_result": [
+          "01"
+        ]
+      },
+      "check": "transaction_type_lookup_runtime_probe",
+      "expected": {
+        "backward_page_type_codes": [
+          "04",
+          "05",
+          "06"
+        ],
+        "category_count": 18,
+        "description_filter_count": 1,
+        "legacy_program": "COTRTLIC",
+        "legacy_transaction": "CTLI",
+        "page_size": 7,
+        "type_count": 7,
+        "type_filter_result": [
+          "01"
+        ]
+      },
+      "passed": true
+    },
+    {
+      "actual": {
+        "approved": true,
+        "approved_count_delta": 1,
+        "invalid_card_response_reason": "3100",
+        "invalid_card_written": false,
+        "response_code": "00",
+        "response_reason": "0000",
+        "written": true
+      },
+      "check": "pending_authorization_cp00_request_response_and_insert_runtime_probe",
+      "expected": {
+        "approved": true,
+        "approved_count_delta": 1,
+        "invalid_card_response_reason": "3100",
+        "invalid_card_written": false,
+        "response_code": "00",
+        "response_reason": "0000",
+        "written": true
+      },
+      "passed": true
+    }
+  ],
+  "claim_limit": "Executable modern replay over static/source-oracle traces only; no live COBOL/CICS runtime replay has been performed.",
+  "edge_case_count": 40,
+  "evidence_hash": "c661998c6538b8118b5abf4d248cad72dfa138e087bded1a4c37a5e6a7377bab",
+  "failed_checks": [],
+  "gap_count": 0,
+  "generated_utc": "2026-05-23T15:01:52+00:00",
+  "golden_trace_count": 34,
+  "grade_counts": {
+    "A": 0,
+    "B": 50,
+    "C": 0,
+    "F": 0
+  },
+  "passed": true,
+  "public_actions_allowed": false,
+  "replay_hash": "912e98e11d46cd967070d06ec17aaed3402bed44026267d1906ea6a2d54b9a42",
+  "replay_version": "modern_carddemo_static_oracle_replay_v0",
+  "runtime_probe_count": 6,
+  "runtime_probes": [
+    {
+      "actual": {
+        "legacy_program": "CODATE01",
+        "legacy_transaction": "CDRD",
+        "reply_message": "SYSTEM DATE : 05-23-2026SYSTEM TIME : 11:12:13",
+        "reply_queue": "CARD.DEMO.REPLY.DATE",
+        "request_payload_validated": false,
+        "system_date": "05-23-2026",
+        "system_time": "11:12:13"
+      },
+      "expected": {
+        "legacy_program": "CODATE01",
+        "legacy_transaction": "CDRD",
+        "reply_message": "SYSTEM DATE : 05-23-2026SYSTEM TIME : 11:12:13",
+        "reply_queue": "CARD.DEMO.REPLY.DATE",
+        "request_payload_validated": false,
+        "system_date": "05-23-2026",
+        "system_time": "11:12:13"
+      },
+      "passed": true,
+      "trace_id": "mq_system_date_cdrd_reply"
+    },
+    {
+      "actual": {
+        "account_id": 1,
+        "active_status": "Y",
+        "bad_function_reply": "INVALID REQUEST PARAMETERS ACCT ID : 00000000001FUNCTION : BAD ",
+        "legacy_program": "COACCT01",
+        "legacy_transaction": "CDRA",
+        "not_found_reply": "INVALID REQUEST PARAMETERS ACCT ID : 99999999999",
+        "reply_has_account_label": true,
+        "reply_queue": "CARD.DEMO.REPLY.ACCT",
+        "request_account_key": "00000000001"
+      },
+      "expected": {
+        "account_id": 1,
+        "active_status": "Y",
+        "bad_function_reply": "INVALID REQUEST PARAMETERS ACCT ID : 00000000001FUNCTION : BAD ",
+        "legacy_program": "COACCT01",
+        "legacy_transaction": "CDRA",
+        "not_found_reply": "INVALID REQUEST PARAMETERS ACCT ID : 99999999999",
+        "reply_has_account_label": true,
+        "reply_queue": "CARD.DEMO.REPLY.ACCT",
+        "request_account_key": "00000000001"
+      },
+      "passed": true,
+      "trace_id": "mq_account_inquiry_cdra_success_and_invalid"
+    },
+    {
+      "actual": {
+        "base_gdg_names": [
+          "AWS.M2.CARDDEMO.TRANSACT.BKUP",
+          "AWS.M2.CARDDEMO.TRANSACT.DALY",
+          "AWS.M2.CARDDEMO.TRANREPT",
+          "AWS.M2.CARDDEMO.TCATBALF.BKUP",
+          "AWS.M2.CARDDEMO.SYSTRAN",
+          "AWS.M2.CARDDEMO.TRANSACT.COMBINED"
+        ],
+        "close_code": "CLO",
+        "db2_first_generation_counts": [
+          7,
+          18,
+          51
+        ],
+        "esds_rrds_organizations": [
+          "NONINDEXED",
+          "NUMBERED"
+        ],
+        "file_sets_match": true,
+        "open_code": "OPE",
+        "resource_count": 6,
+        "tranidx_keys": {
+          "length": 26,
+          "offset": 304
+        },
+        "tranidx_source_count": 300
+      },
+      "expected": {
+        "base_gdg_names": [
+          "AWS.M2.CARDDEMO.TRANSACT.BKUP",
+          "AWS.M2.CARDDEMO.TRANSACT.DALY",
+          "AWS.M2.CARDDEMO.TRANREPT",
+          "AWS.M2.CARDDEMO.TCATBALF.BKUP",
+          "AWS.M2.CARDDEMO.SYSTRAN",
+          "AWS.M2.CARDDEMO.TRANSACT.COMBINED"
+        ],
+        "close_code": "CLO",
+        "db2_first_generation_counts": [
+          7,
+          18,
+          51
+        ],
+        "esds_rrds_organizations": [
+          "NONINDEXED",
+          "NUMBERED"
+        ],
+        "file_sets_match": true,
+        "open_code": "OPE",
+        "resource_count": 6,
+        "tranidx_keys": {
+          "length": 26,
+          "offset": 304
+        },
+        "tranidx_source_count": 300
+      },
+      "passed": true,
+      "trace_id": "batch_resource_setup_gdg_vsam_aix_cics"
+    },
+    {
+      "actual": {
+        "first_transaction_id": "960b9b5480d045a",
+        "next_page": true,
+        "returned_authorizations": 5,
+        "summary_amount_cents": 944,
+        "summary_count": 6
+      },
+      "expected": {
+        "first_transaction_id": "960b9b5480d045a",
+        "next_page": true,
+        "returned_authorizations": 5,
+        "summary_amount_cents": 944,
+        "summary_count": 6
+      },
+      "passed": true,
+      "trace_id": "pending_authorization_cpvs_summary_page"
+    },
+    {
+      "actual": {
+        "backward_page_type_codes": [
+          "04",
+          "05",
+          "06"
+        ],
+        "category_count": 18,
+        "description_filter_count": 1,
+        "legacy_program": "COTRTLIC",
+        "legacy_transaction": "CTLI",
+        "page_size": 7,
+        "type_count": 7,
+        "type_filter_result": [
+          "01"
+        ]
+      },
+      "expected": {
+        "backward_page_type_codes": [
+          "04",
+          "05",
+          "06"
+        ],
+        "category_count": 18,
+        "description_filter_count": 1,
+        "legacy_program": "COTRTLIC",
+        "legacy_transaction": "CTLI",
+        "page_size": 7,
+        "type_count": 7,
+        "type_filter_result": [
+          "01"
+        ]
+      },
+      "passed": true,
+      "trace_id": "transaction_type_lookup"
+    },
+    {
+      "actual": {
+        "approved": true,
+        "approved_count_delta": 1,
+        "invalid_card_response_reason": "3100",
+        "invalid_card_written": false,
+        "response_code": "00",
+        "response_reason": "0000",
+        "written": true
+      },
+      "expected": {
+        "approved": true,
+        "approved_count_delta": 1,
+        "invalid_card_response_reason": "3100",
+        "invalid_card_written": false,
+        "response_code": "00",
+        "response_reason": "0000",
+        "written": true
+      },
+      "passed": true,
+      "trace_id": "pending_authorization_cp00_request_response_and_insert"
+    }
+  ],
+  "scratch_db_path": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\modern_carddemo\\reports\\static_oracle_replay.sqlite",
+  "seed_counts": {
+    "accounts": 50,
+    "card_xrefs": 50,
+    "cards": 50,
+    "customers": 50,
+    "disclosure_groups": 51,
+    "pending_authorization_details": 202,
+    "pending_authorization_summaries": 21,
+    "transaction_categories": 18,
+    "transaction_category_balances": 50,
+    "transaction_types": 7,
+    "transactions": 300,
+    "users": 10
+  },
+  "source_head": "59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e",
+  "source_root": "D:\\scraper_storage\\modernization_labs\\aws-carddemo-modernization-20260523T073000Z\\source",
+  "summary": {
+    "capability_count": 50,
+    "claim_limit": "capability ledger and static-oracle traces only; no all-path COBOL runtime proof yet",
+    "edge_case_count": 40,
+    "gap_count": 0,
+    "golden_trace_count": 34,
+    "grade_counts": {
+      "A": 0,
+      "B": 50,
+      "C": 0,
+      "F": 0
+    },
+    "one_for_one_parity_ready": true,
+    "partial_or_inferred_count": 0,
+    "static_oracle_or_better_count": 50,
+    "strict_runtime_parity_count": 0
+  }
+}

modern_code/README.md

@@ -0,0 +1,83 @@
+# Modern CardDemo
+
+Autonomous best-effort modernization of AWS CardDemo from COBOL/CICS/VSAM/JCL into a small Python web/API application.
+
+## What This Preserves
+
+- The original AWS CardDemo source clone is preserved at `../source`.
+- Seed data is loaded from the original ASCII/EBCDIC files under `../source/app/data`.
+- Fixed-width layouts are derived from CardDemo copybooks for customer, account, card, card xref, transaction, transaction type, transaction category, and user security records.
+- The old system remains the behavioral oracle where it can be exercised. This lab does not require human approval; unresolved behavior becomes an assumption or gap receipt.
+
+## Modern Target
+
+- Standard-library Python 3 application.
+- SQLite persistence.
+- JSON API plus browser UI.
+- No external package install required.
+- Batch/report parity surfaces for `TRANREPT`, `CREASTMT`, `INTCALC`, and `COMBTRAN`.
+- Batch resource setup/control parity metadata for `DEFGDGB`, `DEFGDGD`, `ESDSRRDS`, `TRANIDX`, `CLOSEFIL`, and `OPENFIL`.
+- Signon, regular/admin menu routing, and SQLite-backed user security maintenance for `CC00`, `CM00`, `CA00`, `CU01`, `CU02`, and `CU03`.
+- Transaction type maintenance for `CTTU`, including type-code validation, update/insert, no-change rejection, and guarded delete.
+- MQ request/reply parity surfaces for `CDRD` and `CDRA`, including source-shaped 1000-byte message metadata, system date/time reply formatting, and account inquiry over `ACCTDAT`.
+- Pending authorization IMS/DB2/MQ parity surfaces for `CPVS`, `CPVD`, `CP00`, and `CBPAUP0J`, seeded from the original `DBPAUTP0` IMS unload.
+
+## Run
+
+```powershell
+cd D:\scraper_storage\modernization_labs\aws-carddemo-modernization-20260523T073000Z\modern_carddemo
+python -m carddemo.cli init-db --source-root ..\source --db-path .\carddemo.sqlite
+python -m carddemo.cli serve --source-root ..\source --db-path .\carddemo.sqlite --port 8087
+```
+
+Open `http://127.0.0.1:8087`.
+
+## Test And Receipts
+
+```powershell
+python -m unittest discover -s tests
+python tools\generate_receipts.py --source-root ..\source --db-path .\carddemo.sqlite --out-dir .\reports
+python tools\replay_static_oracles.py --source-root ..\source --out-dir .\reports
+```
+
+Receipt and replay generation write the capability-parity proof pack:
+
+- `reports/capability_ledger.json`: every discovered AWS CardDemo online and batch capability with source refs and proof grade.
+- `reports/golden_traces.json`: deterministic service traces backed by legacy seed files or explicit inferred rules.
+- `reports/edge_cases.json`: data- and copybook-derived edge cases to drive future parity closure.
+- `reports/next_gap_ranking.json`: autonomous next-work queue, sorted by gap severity and capability priority.
+- `reports/static_oracle_replay.json`: executable modern-service replay over the static/source-oracle trace pack, using a scratch SQLite database.
+
+Proof grades are `A` for actual legacy runtime trace match, `B` for static legacy data/copybook oracle match, `C` for implemented or inferred without strict parity proof, and `F` for discovered capability gaps.
+
+## Added Batch/API Surfaces
+
+- `GET /api/reports/transactions`: seed-data transaction detail report following the legacy `TRANREPT` joins and date filter shape.
+- `GET /api/statements/{account_id}`: account statement text/HTML payload following the `CREASTMT` account, customer, card, transaction source sort, 80-byte statement line, and total-expense flow.
+- `GET /api/interest-projection`: `INTCALC` formula preview using `TCATBALF` and `DISCGRP` seed files.
+- `GET /api/batch/combined-transactions`: `COMBTRAN`-style concatenation of `TRANSACT.BKUP(0)` and `SYSTRAN(0)`, ascending `TRAN-ID` sort, `TRANSACT.COMBINED(+1)` output metadata, and transaction KSDS REPRO target metadata.
+- `GET /api/batch/transaction-master-backup`: `TRANBKP`-style transaction master backup/redefine metadata, including `REPROC` source/backup datasets, IDCAMS delete targets, 350-byte KSDS record size, and 16-byte transaction-id key contract.
+- `GET /api/batch/transaction-type-extract`: `TRANEXTR`-style `DSNTIAUL` extract for transaction type/category reference files, including backup/output datasets, ordered 60-byte records, and zero-fill suffixes.
+- `GET /api/batch/db2-reference-setup`: `CREADB21`-style Db2 transaction reference setup, including free-plan/create/load step order, database/tablespace/table/index/grant metadata, load counts, and category-to-type restrict-delete foreign key.
+- `GET /api/batch/resource-setup`: setup/control metadata for `DEFGDGB`, `DEFGDGD`, `ESDSRRDS`, `TRANIDX`, `CLOSEFIL`, and `OPENFIL`; pass `job=<name>` for one source job.
+- `GET`/`POST /api/mq/system-date`: `CDRD`/`CODATE01` MQ request/reply model that returns `SYSTEM DATE : MM-DD-YYYY` and `SYSTEM TIME : HH:MM:SS` using the source reply labels.
+- `GET`/`POST /api/mq/account-inquiry`: `CDRA`/`COACCT01` MQ request/reply model for `INQA` plus an 11-digit account key, returning labeled `ACCTDAT` account fields or the source-shaped invalid-parameters reply.
+- `GET /api/pending-authorizations/summary`: `CPVS` pending authorization summary and five-row page flow over decoded `PAUTSUM0`/`PAUTDTL1` IMS unload records.
+- `GET /api/pending-authorizations/detail`: `CPVD` pending authorization detail lookup by source-shaped authorization key or transaction id.
+- `POST /api/pending-authorizations/process`: `CP00` authorization request processing with comma-delimited MQ request shape, available-credit decision, response CSV, summary update/insert, and detail insert.
+- `POST /api/pending-authorizations/fraud`: `CPVD`/`COPAUS2C` fraud mark/remove flow with `AUTHFRDS` shadow-table write.
+- `POST /api/batch/purge-authorizations`: `CBPAUP0J`/`CBPAUP0C` expired authorization purge using the reverse-date `PA-AUTH-DATE-9C` calculation and summary counter adjustment.
+- `PATCH /api/accounts/{account_id}`: `CAUP` account update flow with account/xref lookup, Y/N status validation, signed money/date validation, no-change rejection, and account/customer SQLite rewrites.
+- `GET /api/cards/{card_number}` and `PATCH /api/cards/{card_number}`: `CCDL`/`CCUP` card detail and update flow with account/card key validation, alphabetic embossed names, Y/N status, expiry month/year validation, no-change rejection, hidden-field preservation, and card SQLite rewrites.
+- `POST /api/transactions`: `CT02` transaction-add flow with account/card xref lookup, confirmation, signed amount/date/merchant validation, transaction-id increment, and `TRANSACT` write without account-balance mutation.
+- `GET /api/transaction-types`: `CTLI` transaction type list view with source-shaped seven-row cursor paging, forward/backward navigation, exact type-code filtering, and `LIKE` description filtering.
+- `POST /api/transaction-types`, `PATCH /api/transaction-types/{type_code}`, and `DELETE /api/transaction-types/{type_code}`: `CTTU` transaction type maintenance with two-digit numeric nonzero type codes, required alphanumeric descriptions, no-change rejection, update-or-insert behavior, and child-record delete protection.
+- `POST /api/batch/transaction-types`: `MNTTRDB2`/`COBTUPDT` batch transaction type maintenance over fixed `INPFILE` records, including `A` add, `U` update, `D` delete, `*` comment handling, return-code 4 error reporting, duplicate/missing-row SQL outcomes, and Db2 restrict-delete behavior.
+- `POST /api/post-transactions`: `POSTTRAN`-style batch posting with card/account lookup, overlimit rejection, expiration rejection, category-balance update, and account cycle update.
+- `POST /api/signon`: `CC00` signon over decoded `USRSEC`, including uppercase credential normalization and admin/user menu routing.
+- `GET /api/menu/main` and `GET /api/menu/admin`: `CM00` and `CA00` menu option surfaces transcribed from the legacy menu copybooks/source.
+- `POST /api/users`, `PATCH /api/users/{user_id}`, and `DELETE /api/users/{user_id}`: `CU01`, `CU02`, and `CU03` user maintenance flows over the modern SQLite user table, including source-shaped blank-field, duplicate, no-change, not-found, and non-admin user-type behavior.
+
+## Current Claim Limit
+
+This is not claimed to be a proven production-equivalent replacement. It is a runnable modern target with seed-data parity checks, source fingerprints, tests, capability proof grades, gap ranking, and executable modern-service replay over static/source-oracle traces. Runtime parity against the original COBOL/CICS execution remains a gap unless a compatible mainframe or emulator harness is attached.

modern_code/carddemo/__init__.py

@@ -0,0 +1,4 @@
+"""Modern CardDemo package."""
+
+__version__ = "0.1.0"
+

modern_code/carddemo/api.py

@@ -0,0 +1,336 @@
+from __future__ import annotations
+
+import json
+import mimetypes
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from urllib.parse import parse_qs, urlparse
+
+from .repository import seed_from_legacy
+from .service import CardDemoService
+
+
+STATIC_ROOT = Path(__file__).resolve().parent.parent / "static"
+
+
+def make_handler(service: CardDemoService, source_root: Path):
+    class Handler(BaseHTTPRequestHandler):
+        server_version = "ModernCardDemo/0.1"
+
+        def do_GET(self) -> None:
+            parsed = urlparse(self.path)
+            query = parse_qs(parsed.query)
+            try:
+                if parsed.path == "/api/health":
+                    self.json_response({"status": "ok", "source_root": str(source_root)})
+                elif parsed.path == "/api/summary":
+                    self.json_response(service.summary())
+                elif parsed.path == "/api/menu/main":
+                    self.json_response(service.main_menu(user_type=(query.get("user_type") or ["U"])[0]))
+                elif parsed.path == "/api/menu/admin":
+                    self.json_response(service.admin_menu())
+                elif parsed.path == "/api/customers":
+                    self.json_response(
+                        service.list_customers(
+                            query=(query.get("query") or [""])[0],
+                            limit=int((query.get("limit") or ["50"])[0]),
+                        )
+                    )
+                elif parsed.path == "/api/accounts":
+                    customer_id = (query.get("customer_id") or [""])[0]
+                    self.json_response(
+                        service.list_accounts(
+                            customer_id=int(customer_id) if customer_id else None,
+                            limit=int((query.get("limit") or ["50"])[0]),
+                        )
+                    )
+                elif parsed.path.startswith("/api/accounts/"):
+                    account_id = int(parsed.path.rsplit("/", 1)[-1])
+                    bundle = service.get_account_bundle(account_id)
+                    if not bundle:
+                        self.error_response(404, "account not found")
+                    else:
+                        self.json_response(bundle)
+                elif parsed.path == "/api/cards":
+                    account_id = (query.get("account_id") or [""])[0]
+                    customer_id = (query.get("customer_id") or [""])[0]
+                    self.json_response(
+                        service.list_cards(
+                            account_id=int(account_id) if account_id else None,
+                            customer_id=int(customer_id) if customer_id else None,
+                        )
+                    )
+                elif parsed.path.startswith("/api/cards/"):
+                    card_number = parsed.path.rsplit("/", 1)[-1]
+                    account_id = (query.get("account_id") or [""])[0]
+                    self.json_response(service.get_card_detail(card_number, account_id=account_id or None))
+                elif parsed.path == "/api/transactions":
+                    account_id = (query.get("account_id") or [""])[0]
+                    self.json_response(
+                        service.list_transactions(
+                            account_id=int(account_id) if account_id else None,
+                            card_number=(query.get("card_number") or [""])[0] or None,
+                            limit=int((query.get("limit") or ["100"])[0]),
+                        )
+                    )
+                elif parsed.path == "/api/reports/transactions":
+                    account_id = (query.get("account_id") or [""])[0]
+                    self.json_response(
+                        service.transaction_report(
+                            start_date=(query.get("start_date") or [""])[0] or None,
+                            end_date=(query.get("end_date") or [""])[0] or None,
+                            account_id=int(account_id) if account_id else None,
+                            card_number=(query.get("card_number") or [""])[0] or None,
+                            limit=int((query.get("limit") or ["1000"])[0]),
+                        )
+                    )
+                elif parsed.path.startswith("/api/statements/"):
+                    account_id = int(parsed.path.rsplit("/", 1)[-1])
+                    self.json_response(service.account_statement(account_id))
+                elif parsed.path == "/api/interest-projection":
+                    self.json_response(
+                        service.interest_projection(
+                            processing_date=(query.get("processing_date") or [""])[0] or None,
+                            limit=int((query.get("limit") or ["1000"])[0]),
+                        )
+                    )
+                elif parsed.path == "/api/batch/combined-transactions":
+                    self.json_response(
+                        service.combined_transactions(
+                            processing_date=(query.get("processing_date") or [""])[0] or None,
+                            limit=int((query.get("limit") or ["1000"])[0]),
+                        )
+                    )
+                elif parsed.path == "/api/batch/transaction-master-backup":
+                    self.json_response(
+                        service.transaction_master_backup(
+                            limit=int((query.get("limit") or ["20"])[0]),
+                        )
+                    )
+                elif parsed.path == "/api/batch/transaction-type-extract":
+                    self.json_response(service.transaction_type_extract())
+                elif parsed.path == "/api/batch/db2-reference-setup":
+                    self.json_response(service.db2_reference_setup())
+                elif parsed.path == "/api/batch/resource-setup":
+                    self.json_response(
+                        service.batch_resource_setup(
+                            job=(query.get("job") or [""])[0] or None,
+                        )
+                    )
+                elif parsed.path == "/api/mq/system-date":
+                    self.json_response(
+                        service.mq_system_date(
+                            {
+                                "now": (query.get("now") or [""])[0] or None,
+                                "request_message": (query.get("request_message") or [""])[0] or None,
+                            }
+                        )
+                    )
+                elif parsed.path == "/api/mq/account-inquiry":
+                    self.json_response(
+                        service.mq_account_inquiry(
+                            {
+                                "function": (query.get("function") or ["INQA"])[0],
+                                "account_id": (query.get("account_id") or query.get("account_number") or ["0"])[0],
+                                "request_message": (query.get("request_message") or [""])[0] or None,
+                            }
+                        )
+                    )
+                elif parsed.path == "/api/pending-authorizations/summary":
+                    self.json_response(
+                        service.pending_authorization_summary(
+                            int((query.get("account_id") or ["0"])[0]),
+                            start_key=(query.get("start_key") or [""])[0] or None,
+                            page_size=int((query.get("page_size") or ["5"])[0]),
+                        )
+                    )
+                elif parsed.path == "/api/pending-authorizations/detail":
+                    self.json_response(
+                        service.pending_authorization_detail(
+                            int((query.get("account_id") or ["0"])[0]),
+                            authorization_key=(query.get("authorization_key") or [""])[0] or None,
+                            transaction_id=(query.get("transaction_id") or [""])[0] or None,
+                        )
+                    )
+                elif parsed.path == "/api/users":
+                    self.json_response(service.list_users())
+                elif parsed.path.startswith("/api/users/"):
+                    user_id = parsed.path.rsplit("/", 1)[-1]
+                    user = service.get_user(user_id)
+                    if not user:
+                        self.error_response(404, "User ID NOT found...")
+                    else:
+                        self.json_response(user)
+                elif parsed.path == "/api/transaction-types":
+                    self.json_response(
+                        service.transaction_types(
+                            start_key=(query.get("start_key") or [""])[0],
+                            direction=(query.get("direction") or ["forward"])[0],
+                            type_filter=(query.get("type_code") or [""])[0] or None,
+                            description_filter=(query.get("description") or [""])[0] or None,
+                            page_size=int((query.get("page_size") or ["7"])[0]),
+                        )
+                    )
+                elif parsed.path == "/" or parsed.path.startswith("/static/"):
+                    self.static_response(parsed.path)
+                else:
+                    self.error_response(404, "not found")
+            except KeyError as exc:
+                self.error_response(404, str(exc))
+            except ValueError as exc:
+                self.error_response(400, str(exc))
+            except Exception as exc:  # pragma: no cover - defensive API boundary
+                self.error_response(500, str(exc))
+
+        def do_POST(self) -> None:
+            parsed = urlparse(self.path)
+            try:
+                payload = self.read_json()
+                if parsed.path == "/api/signon":
+                    self.json_response(service.signon(payload.get("user_id", ""), payload.get("password", "")))
+                elif parsed.path == "/api/users":
+                    self.json_response(service.add_user(payload), status=201)
+                elif parsed.path == "/api/transactions":
+                    self.json_response(service.add_transaction(payload), status=201)
+                elif parsed.path == "/api/transaction-types":
+                    result = service.upsert_transaction_type(payload)
+                    self.json_response(result, status=201 if result["action"] == "inserted" else 200)
+                elif parsed.path == "/api/batch/transaction-types":
+                    records = payload.get("records")
+                    if records is None:
+                        records = str(payload.get("input_text", "")).splitlines()
+                    self.json_response(
+                        service.maintain_transaction_types(
+                            records,
+                            dry_run=bool(payload.get("dry_run", False)),
+                        )
+                    )
+                elif parsed.path == "/api/mq/system-date":
+                    self.json_response(service.mq_system_date(payload))
+                elif parsed.path == "/api/mq/account-inquiry":
+                    self.json_response(service.mq_account_inquiry(payload))
+                elif parsed.path == "/api/pending-authorizations/process":
+                    self.json_response(service.process_authorization_request(payload), status=201)
+                elif parsed.path == "/api/pending-authorizations/fraud":
+                    self.json_response(
+                        service.mark_authorization_fraud(
+                            int(payload.get("account_id")),
+                            str(payload.get("authorization_key")),
+                            action=str(payload.get("action") or "toggle"),
+                            report_date=payload.get("report_date"),
+                        )
+                    )
+                elif parsed.path == "/api/batch/purge-authorizations":
+                    self.json_response(
+                        service.purge_expired_authorizations(
+                            current_yyddd=payload.get("current_yyddd"),
+                            expiry_days=int(payload.get("expiry_days", 5)),
+                            dry_run=bool(payload.get("dry_run", False)),
+                        )
+                    )
+                elif parsed.path == "/api/bill-payments":
+                    amount = payload.get("amount_cents")
+                    self.json_response(
+                        service.bill_payment(
+                            account_id=int(payload.get("account_id")),
+                            amount_cents=int(amount) if amount is not None else None,
+                        ),
+                        status=201,
+                    )
+                elif parsed.path == "/api/post-transactions":
+                    result = service.post_transaction(payload, reject_on_failure=False)
+                    self.json_response(result, status=201 if result["accepted"] else 422)
+                elif parsed.path == "/api/admin/reseed":
+                    counts = seed_from_legacy(source_root, service.db_path, reset=True)
+                    self.json_response({"status": "reseeded", "counts": counts})
+                else:
+                    self.error_response(404, "not found")
+            except Exception as exc:
+                self.error_response(400, str(exc))
+
+        def do_PATCH(self) -> None:
+            parsed = urlparse(self.path)
+            try:
+                payload = self.read_json()
+                if parsed.path.startswith("/api/accounts/"):
+                    account_id = int(parsed.path.rsplit("/", 1)[-1])
+                    self.json_response(service.update_account(account_id, payload))
+                elif parsed.path.startswith("/api/cards/"):
+                    card_number = parsed.path.rsplit("/", 1)[-1]
+                    self.json_response(service.update_card(card_number, payload))
+                elif parsed.path.startswith("/api/users/"):
+                    user_id = parsed.path.rsplit("/", 1)[-1]
+                    self.json_response(service.update_user(user_id, payload))
+                elif parsed.path.startswith("/api/transaction-types/"):
+                    type_code = parsed.path.rsplit("/", 1)[-1]
+                    self.json_response(service.upsert_transaction_type({**payload, "type_code": type_code}))
+                else:
+                    self.error_response(404, "not found")
+            except KeyError as exc:
+                self.error_response(404, str(exc))
+            except Exception as exc:
+                self.error_response(400, str(exc))
+
+        def do_DELETE(self) -> None:
+            parsed = urlparse(self.path)
+            try:
+                if parsed.path.startswith("/api/users/"):
+                    user_id = parsed.path.rsplit("/", 1)[-1]
+                    self.json_response(service.delete_user(user_id))
+                elif parsed.path.startswith("/api/transaction-types/"):
+                    type_code = parsed.path.rsplit("/", 1)[-1]
+                    self.json_response(service.delete_transaction_type(type_code))
+                else:
+                    self.error_response(404, "not found")
+            except KeyError as exc:
+                self.error_response(404, str(exc))
+            except Exception as exc:
+                self.error_response(400, str(exc))
+
+        def read_json(self) -> dict:
+            length = int(self.headers.get("Content-Length") or "0")
+            if not length:
+                return {}
+            return json.loads(self.rfile.read(length).decode("utf-8"))
+
+        def json_response(self, payload, status: int = 200) -> None:
+            body = json.dumps(payload, indent=2).encode("utf-8")
+            self.send_response(status)
+            self.send_header("Content-Type", "application/json; charset=utf-8")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+
+        def error_response(self, status: int, message: str) -> None:
+            self.json_response({"error": message}, status=status)
+
+        def static_response(self, path: str) -> None:
+            rel = "index.html" if path == "/" else path.removeprefix("/static/")
+            target = (STATIC_ROOT / rel).resolve()
+            if STATIC_ROOT not in target.parents and target != STATIC_ROOT:
+                self.error_response(403, "forbidden")
+                return
+            if not target.exists() or not target.is_file():
+                self.error_response(404, "not found")
+                return
+            body = target.read_bytes()
+            content_type = mimetypes.guess_type(str(target))[0] or "application/octet-stream"
+            self.send_response(200)
+            self.send_header("Content-Type", content_type)
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+
+        def log_message(self, fmt: str, *args) -> None:
+            print(f"{self.address_string()} - {fmt % args}")
+
+    return Handler
+
+
+def serve(source_root: Path, db_path: Path, host: str = "127.0.0.1", port: int = 8087) -> None:
+    if not db_path.exists():
+        seed_from_legacy(source_root, db_path, reset=True)
+    service = CardDemoService(db_path)
+    server = ThreadingHTTPServer((host, port), make_handler(service, source_root))
+    print(f"Modern CardDemo serving http://{host}:{port}")
+    server.serve_forever()

modern_code/carddemo/cli.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from .api import serve
+from .repository import seed_from_legacy
+from .service import CardDemoService
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Modern CardDemo runner")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    init_db = sub.add_parser("init-db", help="Initialize SQLite from legacy CardDemo data")
+    init_db.add_argument("--source-root", type=Path, required=True)
+    init_db.add_argument("--db-path", type=Path, required=True)
+
+    serve_cmd = sub.add_parser("serve", help="Serve the modern web/API app")
+    serve_cmd.add_argument("--source-root", type=Path, required=True)
+    serve_cmd.add_argument("--db-path", type=Path, required=True)
+    serve_cmd.add_argument("--host", default="127.0.0.1")
+    serve_cmd.add_argument("--port", type=int, default=8087)
+
+    summary = sub.add_parser("summary", help="Print database summary")
+    summary.add_argument("--db-path", type=Path, required=True)
+
+    args = parser.parse_args()
+    if args.command == "init-db":
+        counts = seed_from_legacy(args.source_root, args.db_path, reset=True)
+        print(counts)
+    elif args.command == "serve":
+        serve(args.source_root, args.db_path, host=args.host, port=args.port)
+    elif args.command == "summary":
+        print(CardDemoService(args.db_path).summary())
+
+
+if __name__ == "__main__":
+    main()
+

modern_code/carddemo/legacy_parser.py

@@ -0,0 +1,384 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable
+
+
+POS_OVERPUNCH = {
+    "{": "0",
+    "A": "1",
+    "B": "2",
+    "C": "3",
+    "D": "4",
+    "E": "5",
+    "F": "6",
+    "G": "7",
+    "H": "8",
+    "I": "9",
+}
+NEG_OVERPUNCH = {
+    "}": "0",
+    "J": "1",
+    "K": "2",
+    "L": "3",
+    "M": "4",
+    "N": "5",
+    "O": "6",
+    "P": "7",
+    "Q": "8",
+    "R": "9",
+}
+
+
+@dataclass(frozen=True)
+class Field:
+    name: str
+    start: int
+    length: int
+    kind: str = "text"
+    scale: int = 0
+
+
+CUSTOMER_FIELDS = [
+    Field("customer_id", 0, 9, "int"),
+    Field("first_name", 9, 25),
+    Field("middle_name", 34, 25),
+    Field("last_name", 59, 25),
+    Field("address_line_1", 84, 50),
+    Field("address_line_2", 134, 50),
+    Field("address_line_3", 184, 50),
+    Field("state", 234, 2),
+    Field("country", 236, 3),
+    Field("zip_code", 239, 10),
+    Field("phone_1", 249, 15),
+    Field("phone_2", 264, 15),
+    Field("ssn", 279, 9),
+    Field("government_id", 288, 20),
+    Field("date_of_birth", 308, 10),
+    Field("eft_account_id", 318, 10),
+    Field("primary_card_holder", 328, 1),
+    Field("fico_score", 329, 3, "int"),
+]
+
+ACCOUNT_FIELDS = [
+    Field("account_id", 0, 11, "int"),
+    Field("active_status", 11, 1),
+    Field("current_balance_cents", 12, 12, "money", 2),
+    Field("credit_limit_cents", 24, 12, "money", 2),
+    Field("cash_credit_limit_cents", 36, 12, "money", 2),
+    Field("open_date", 48, 10),
+    Field("expiration_date", 58, 10),
+    Field("reissue_date", 68, 10),
+    Field("current_cycle_credit_cents", 78, 12, "money", 2),
+    Field("current_cycle_debit_cents", 90, 12, "money", 2),
+    Field("zip_code", 102, 10),
+    Field("group_id", 112, 10),
+]
+
+CARD_FIELDS = [
+    Field("card_number", 0, 16),
+    Field("account_id", 16, 11, "int"),
+    Field("cvv", 27, 3),
+    Field("embossed_name", 30, 50),
+    Field("expiration_date", 80, 10),
+    Field("active_status", 90, 1),
+]
+
+CARD_XREF_FIELDS = [
+    Field("card_number", 0, 16),
+    Field("customer_id", 16, 9, "int"),
+    Field("account_id", 25, 11, "int"),
+]
+
+TRANSACTION_FIELDS = [
+    Field("transaction_id", 0, 16),
+    Field("type_code", 16, 2),
+    Field("category_code", 18, 4),
+    Field("source", 22, 10),
+    Field("description", 32, 100),
+    Field("amount_cents", 132, 11, "money", 2),
+    Field("merchant_id", 143, 9),
+    Field("merchant_name", 152, 50),
+    Field("merchant_city", 202, 50),
+    Field("merchant_zip", 252, 10),
+    Field("card_number", 262, 16),
+    Field("original_timestamp", 278, 26),
+    Field("processed_timestamp", 304, 26),
+]
+
+TRANSACTION_TYPE_FIELDS = [
+    Field("type_code", 0, 2),
+    Field("description", 2, 50),
+]
+
+TRANSACTION_CATEGORY_FIELDS = [
+    Field("type_code", 0, 2),
+    Field("category_code", 2, 4),
+    Field("description", 6, 50),
+]
+
+DISCLOSURE_GROUP_FIELDS = [
+    Field("group_id", 0, 10),
+    Field("type_code", 10, 2),
+    Field("category_code", 12, 4),
+    Field("interest_rate_basis_points", 16, 6, "money", 2),
+]
+
+TRANSACTION_CATEGORY_BALANCE_FIELDS = [
+    Field("account_id", 0, 11, "int"),
+    Field("type_code", 11, 2),
+    Field("category_code", 13, 4),
+    Field("balance_cents", 17, 11, "money", 2),
+]
+
+USER_FIELDS = [
+    Field("user_id", 0, 8),
+    Field("first_name", 8, 20),
+    Field("last_name", 28, 20),
+    Field("password", 48, 8),
+    Field("user_type", 56, 1),
+]
+
+PAUTSUM0_MARKER = b"\xd7\xc1\xe4\xe3\xe2\xe4\xd4\xf0"
+PAUTDTL1_MARKER = b"\xd7\xc1\xe4\xe3\xc4\xe3\xd3\xf1"
+IMS_UNLOAD_SEGMENT_DATA_OFFSET = 29
+
+
+def parse_overpunch_int(raw: str) -> int:
+    text = raw.strip()
+    if not text:
+        return 0
+    last = text[-1]
+    sign = 1
+    if last in POS_OVERPUNCH:
+        text = text[:-1] + POS_OVERPUNCH[last]
+    elif last in NEG_OVERPUNCH:
+        text = text[:-1] + NEG_OVERPUNCH[last]
+        sign = -1
+    elif last in "+-":
+        sign = -1 if last == "-" else 1
+        text = text[:-1]
+    return sign * int(text or "0")
+
+
+def parse_money(raw: str, scale: int = 2) -> int:
+    return parse_overpunch_int(raw) if scale == 2 else parse_overpunch_int(raw)
+
+
+def money_to_display(cents: int | None) -> str:
+    cents = int(cents or 0)
+    sign = "-" if cents < 0 else ""
+    value = abs(cents)
+    return f"{sign}{value // 100}.{value % 100:02d}"
+
+
+def parse_fixed_width(line: str, fields: Iterable[Field]) -> dict[str, object]:
+    out: dict[str, object] = {}
+    for field in fields:
+        raw = line[field.start : field.start + field.length]
+        if field.kind == "int":
+            out[field.name] = int(raw.strip() or "0")
+        elif field.kind == "money":
+            out[field.name] = parse_money(raw, field.scale)
+        else:
+            out[field.name] = raw.rstrip()
+    return out
+
+
+def fixed_lines(path: Path, width: int | None = None, encoding: str = "utf-8") -> list[str]:
+    text = path.read_text(encoding=encoding)
+    lines = text.splitlines()
+    if width and len(lines) == 1 and len(lines[0]) > width:
+        joined = lines[0]
+        return [joined[index : index + width] for index in range(0, len(joined), width)]
+    return [line for line in lines if line]
+
+
+def parse_ascii_file(path: Path, fields: Iterable[Field], width: int) -> list[dict[str, object]]:
+    return [parse_fixed_width(line.ljust(width), fields) for line in fixed_lines(path, width=width)]
+
+
+def parse_user_security(path: Path) -> list[dict[str, object]]:
+    raw = path.read_bytes()
+    decoded = raw.decode("cp037")
+    records: list[dict[str, object]] = []
+    for index in range(0, len(decoded), 80):
+        chunk = decoded[index : index + 80]
+        if not chunk.strip():
+            continue
+        records.append(parse_fixed_width(chunk.ljust(80), USER_FIELDS))
+    return records
+
+
+def parse_packed_decimal(raw: bytes) -> int:
+    digits: list[str] = []
+    sign = 1
+    for index, byte in enumerate(raw):
+        high = byte >> 4
+        low = byte & 0x0F
+        if index == len(raw) - 1:
+            if high > 9 or low not in (0x0C, 0x0D, 0x0F):
+                raise ValueError(f"invalid packed decimal byte: {byte:02x}")
+            digits.append(str(high))
+            sign = -1 if low == 0x0D else 1
+        else:
+            if high > 9 or low > 9:
+                raise ValueError(f"invalid packed decimal byte: {byte:02x}")
+            digits.extend((str(high), str(low)))
+    return sign * int("".join(digits) or "0")
+
+
+def parse_comp(raw: bytes) -> int:
+    return int.from_bytes(raw, "big", signed=True)
+
+
+def _ebcdic_text(raw: bytes) -> str:
+    return raw.decode("cp037", errors="replace").replace("\x00", "").rstrip()
+
+
+def _iter_ims_unload_segments(raw: bytes):
+    markers: list[tuple[int, str]] = []
+    for marker, name in ((PAUTSUM0_MARKER, "summary"), (PAUTDTL1_MARKER, "detail")):
+        start = 0
+        while True:
+            offset = raw.find(marker, start)
+            if offset < 0:
+                break
+            markers.append((offset, name))
+            start = offset + 1
+    for offset, name in sorted(markers):
+        length = 100 if name == "summary" else 200
+        data_start = offset + IMS_UNLOAD_SEGMENT_DATA_OFFSET
+        yield offset, name, raw[data_start : data_start + length]
+
+
+def _parse_pending_authorization_summary(raw: bytes, sequence_no: int) -> dict[str, object]:
+    offset = 0
+    account_id = parse_packed_decimal(raw[offset : offset + 6])
+    offset += 6
+    customer_id = int(_ebcdic_text(raw[offset : offset + 9]) or "0")
+    offset += 9
+    auth_status = _ebcdic_text(raw[offset : offset + 1])
+    offset += 1
+    account_statuses = []
+    for _ in range(5):
+        account_statuses.append(_ebcdic_text(raw[offset : offset + 2]))
+        offset += 2
+    credit_limit_cents = parse_packed_decimal(raw[offset : offset + 6])
+    offset += 6
+    cash_limit_cents = parse_packed_decimal(raw[offset : offset + 6])
+    offset += 6
+    credit_balance_cents = parse_packed_decimal(raw[offset : offset + 6])
+    offset += 6
+    cash_balance_cents = parse_packed_decimal(raw[offset : offset + 6])
+    offset += 6
+    approved_auth_count = parse_comp(raw[offset : offset + 2])
+    offset += 2
+    declined_auth_count = parse_comp(raw[offset : offset + 2])
+    offset += 2
+    approved_auth_amount_cents = parse_packed_decimal(raw[offset : offset + 6])
+    offset += 6
+    declined_auth_amount_cents = parse_packed_decimal(raw[offset : offset + 6])
+    offset += 6
+    return {
+        "account_id": account_id,
+        "customer_id": customer_id,
+        "sequence_no": sequence_no,
+        "auth_status": auth_status,
+        "account_status_1": account_statuses[0],
+        "account_status_2": account_statuses[1],
+        "account_status_3": account_statuses[2],
+        "account_status_4": account_statuses[3],
+        "account_status_5": account_statuses[4],
+        "credit_limit_cents": credit_limit_cents,
+        "cash_limit_cents": cash_limit_cents,
+        "credit_balance_cents": credit_balance_cents,
+        "cash_balance_cents": cash_balance_cents,
+        "approved_auth_count": approved_auth_count,
+        "declined_auth_count": declined_auth_count,
+        "approved_auth_amount_cents": approved_auth_amount_cents,
+        "declined_auth_amount_cents": declined_auth_amount_cents,
+    }
+
+
+def _parse_pending_authorization_detail(raw: bytes, account_id: int, sequence_no: int) -> dict[str, object]:
+    offset = 0
+    authorization_key = raw[offset : offset + 8]
+    auth_date_key = parse_packed_decimal(raw[offset : offset + 3])
+    offset += 3
+    auth_time_key = parse_packed_decimal(raw[offset : offset + 5])
+    offset += 5
+
+    def text_field(length: int) -> str:
+        nonlocal offset
+        value = _ebcdic_text(raw[offset : offset + length])
+        offset += length
+        return value
+
+    detail: dict[str, object] = {
+        "account_id": account_id,
+        "sequence_no": sequence_no,
+        "authorization_key": authorization_key.hex(),
+        "auth_date_key": auth_date_key,
+        "auth_time_key": auth_time_key,
+        "auth_yyddd": 99999 - auth_date_key,
+        "auth_orig_date": text_field(6),
+        "auth_orig_time": text_field(6),
+        "card_number": text_field(16),
+        "auth_type": text_field(4),
+        "card_expiry_date": text_field(4),
+        "message_type": text_field(6),
+        "message_source": text_field(6),
+        "auth_id_code": text_field(6),
+        "auth_resp_code": text_field(2),
+        "auth_resp_reason": text_field(4),
+        "processing_code": text_field(6),
+    }
+    detail["transaction_amount_cents"] = parse_packed_decimal(raw[offset : offset + 7])
+    offset += 7
+    detail["approved_amount_cents"] = parse_packed_decimal(raw[offset : offset + 7])
+    offset += 7
+    detail.update(
+        {
+            "merchant_category_code": text_field(4),
+            "acqr_country_code": text_field(3),
+            "pos_entry_mode": text_field(2),
+            "merchant_id": text_field(15),
+            "merchant_name": text_field(22),
+            "merchant_city": text_field(13),
+            "merchant_state": text_field(2),
+            "merchant_zip": text_field(9),
+            "transaction_id": text_field(15),
+            "match_status": text_field(1),
+            "auth_fraud": text_field(1),
+            "fraud_rpt_date": text_field(8),
+        }
+    )
+    return detail
+
+
+def parse_pending_authorizations(path: Path) -> dict[str, list[dict[str, object]]]:
+    raw = path.read_bytes()
+    summaries: list[dict[str, object]] = []
+    details: list[dict[str, object]] = []
+    current_account_id: int | None = None
+
+    for _, segment_name, segment_data in _iter_ims_unload_segments(raw):
+        try:
+            if segment_name == "summary":
+                summary = _parse_pending_authorization_summary(segment_data, len(summaries) + 1)
+                account_id = int(summary["account_id"])
+                if account_id <= 0 or account_id > 99_999_999_999 or int(summary["customer_id"]) <= 0:
+                    continue
+                summaries.append(summary)
+                current_account_id = account_id
+            elif current_account_id is not None:
+                detail = _parse_pending_authorization_detail(segment_data, current_account_id, len(details) + 1)
+                if not str(detail["card_number"]).isdigit() or not str(detail["auth_orig_date"]).isdigit():
+                    continue
+                details.append(detail)
+        except (ValueError, UnicodeDecodeError):
+            continue
+
+    return {"summaries": summaries, "details": details}

modern_code/carddemo/repository.py

@@ -0,0 +1,346 @@
+from __future__ import annotations
+
+import sqlite3
+from pathlib import Path
+from typing import Any
+
+from .legacy_parser import (
+    ACCOUNT_FIELDS,
+    CARD_FIELDS,
+    CARD_XREF_FIELDS,
+    CUSTOMER_FIELDS,
+    DISCLOSURE_GROUP_FIELDS,
+    TRANSACTION_CATEGORY_BALANCE_FIELDS,
+    TRANSACTION_CATEGORY_FIELDS,
+    TRANSACTION_FIELDS,
+    TRANSACTION_TYPE_FIELDS,
+    parse_ascii_file,
+    parse_pending_authorizations,
+    parse_user_security,
+)
+
+
+SCHEMA = """
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE IF NOT EXISTS customers (
+    customer_id INTEGER PRIMARY KEY,
+    first_name TEXT NOT NULL,
+    middle_name TEXT NOT NULL,
+    last_name TEXT NOT NULL,
+    address_line_1 TEXT NOT NULL,
+    address_line_2 TEXT NOT NULL,
+    address_line_3 TEXT NOT NULL,
+    state TEXT NOT NULL,
+    country TEXT NOT NULL,
+    zip_code TEXT NOT NULL,
+    phone_1 TEXT NOT NULL,
+    phone_2 TEXT NOT NULL,
+    ssn TEXT NOT NULL,
+    government_id TEXT NOT NULL,
+    date_of_birth TEXT NOT NULL,
+    eft_account_id TEXT NOT NULL,
+    primary_card_holder TEXT NOT NULL,
+    fico_score INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS accounts (
+    account_id INTEGER PRIMARY KEY,
+    active_status TEXT NOT NULL,
+    current_balance_cents INTEGER NOT NULL,
+    credit_limit_cents INTEGER NOT NULL,
+    cash_credit_limit_cents INTEGER NOT NULL,
+    open_date TEXT NOT NULL,
+    expiration_date TEXT NOT NULL,
+    reissue_date TEXT NOT NULL,
+    current_cycle_credit_cents INTEGER NOT NULL,
+    current_cycle_debit_cents INTEGER NOT NULL,
+    zip_code TEXT NOT NULL,
+    group_id TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS cards (
+    card_number TEXT PRIMARY KEY,
+    account_id INTEGER NOT NULL,
+    cvv TEXT NOT NULL,
+    embossed_name TEXT NOT NULL,
+    expiration_date TEXT NOT NULL,
+    active_status TEXT NOT NULL,
+    FOREIGN KEY(account_id) REFERENCES accounts(account_id)
+);
+
+CREATE TABLE IF NOT EXISTS card_xrefs (
+    card_number TEXT PRIMARY KEY,
+    customer_id INTEGER NOT NULL,
+    account_id INTEGER NOT NULL,
+    FOREIGN KEY(customer_id) REFERENCES customers(customer_id),
+    FOREIGN KEY(account_id) REFERENCES accounts(account_id)
+);
+
+CREATE TABLE IF NOT EXISTS transactions (
+    transaction_id TEXT PRIMARY KEY,
+    type_code TEXT NOT NULL,
+    category_code TEXT NOT NULL,
+    source TEXT NOT NULL,
+    description TEXT NOT NULL,
+    amount_cents INTEGER NOT NULL,
+    merchant_id TEXT NOT NULL,
+    merchant_name TEXT NOT NULL,
+    merchant_city TEXT NOT NULL,
+    merchant_zip TEXT NOT NULL,
+    card_number TEXT NOT NULL,
+    original_timestamp TEXT NOT NULL,
+    processed_timestamp TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS transaction_types (
+    type_code TEXT PRIMARY KEY,
+    description TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS transaction_categories (
+    type_code TEXT NOT NULL,
+    category_code TEXT NOT NULL,
+    description TEXT NOT NULL,
+    PRIMARY KEY(type_code, category_code)
+);
+
+CREATE TABLE IF NOT EXISTS disclosure_groups (
+    group_id TEXT NOT NULL,
+    type_code TEXT NOT NULL,
+    category_code TEXT NOT NULL,
+    interest_rate_basis_points INTEGER NOT NULL,
+    PRIMARY KEY(group_id, type_code, category_code)
+);
+
+CREATE TABLE IF NOT EXISTS transaction_category_balances (
+    account_id INTEGER NOT NULL,
+    type_code TEXT NOT NULL,
+    category_code TEXT NOT NULL,
+    balance_cents INTEGER NOT NULL,
+    PRIMARY KEY(account_id, type_code, category_code),
+    FOREIGN KEY(account_id) REFERENCES accounts(account_id)
+);
+
+CREATE TABLE IF NOT EXISTS users (
+    user_id TEXT PRIMARY KEY,
+    first_name TEXT NOT NULL,
+    last_name TEXT NOT NULL,
+    password TEXT NOT NULL,
+    user_type TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS pending_authorization_summaries (
+    account_id INTEGER PRIMARY KEY,
+    customer_id INTEGER NOT NULL,
+    sequence_no INTEGER NOT NULL,
+    auth_status TEXT NOT NULL,
+    account_status_1 TEXT NOT NULL,
+    account_status_2 TEXT NOT NULL,
+    account_status_3 TEXT NOT NULL,
+    account_status_4 TEXT NOT NULL,
+    account_status_5 TEXT NOT NULL,
+    credit_limit_cents INTEGER NOT NULL,
+    cash_limit_cents INTEGER NOT NULL,
+    credit_balance_cents INTEGER NOT NULL,
+    cash_balance_cents INTEGER NOT NULL,
+    approved_auth_count INTEGER NOT NULL,
+    declined_auth_count INTEGER NOT NULL,
+    approved_auth_amount_cents INTEGER NOT NULL,
+    declined_auth_amount_cents INTEGER NOT NULL,
+    FOREIGN KEY(account_id) REFERENCES accounts(account_id),
+    FOREIGN KEY(customer_id) REFERENCES customers(customer_id)
+);
+
+CREATE TABLE IF NOT EXISTS pending_authorization_details (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    account_id INTEGER NOT NULL,
+    sequence_no INTEGER NOT NULL,
+    authorization_key TEXT NOT NULL,
+    auth_date_key INTEGER NOT NULL,
+    auth_time_key INTEGER NOT NULL,
+    auth_yyddd INTEGER NOT NULL,
+    auth_orig_date TEXT NOT NULL,
+    auth_orig_time TEXT NOT NULL,
+    card_number TEXT NOT NULL,
+    auth_type TEXT NOT NULL,
+    card_expiry_date TEXT NOT NULL,
+    message_type TEXT NOT NULL,
+    message_source TEXT NOT NULL,
+    auth_id_code TEXT NOT NULL,
+    auth_resp_code TEXT NOT NULL,
+    auth_resp_reason TEXT NOT NULL,
+    processing_code TEXT NOT NULL,
+    transaction_amount_cents INTEGER NOT NULL,
+    approved_amount_cents INTEGER NOT NULL,
+    merchant_category_code TEXT NOT NULL,
+    acqr_country_code TEXT NOT NULL,
+    pos_entry_mode TEXT NOT NULL,
+    merchant_id TEXT NOT NULL,
+    merchant_name TEXT NOT NULL,
+    merchant_city TEXT NOT NULL,
+    merchant_state TEXT NOT NULL,
+    merchant_zip TEXT NOT NULL,
+    transaction_id TEXT NOT NULL,
+    match_status TEXT NOT NULL,
+    auth_fraud TEXT NOT NULL,
+    fraud_rpt_date TEXT NOT NULL,
+    UNIQUE(account_id, authorization_key),
+    FOREIGN KEY(account_id) REFERENCES pending_authorization_summaries(account_id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS authorization_frauds (
+    card_number TEXT NOT NULL,
+    auth_timestamp TEXT NOT NULL,
+    account_id INTEGER NOT NULL,
+    customer_id INTEGER NOT NULL,
+    authorization_key TEXT NOT NULL,
+    auth_type TEXT NOT NULL,
+    card_expiry_date TEXT NOT NULL,
+    message_type TEXT NOT NULL,
+    message_source TEXT NOT NULL,
+    auth_id_code TEXT NOT NULL,
+    auth_resp_code TEXT NOT NULL,
+    auth_resp_reason TEXT NOT NULL,
+    processing_code TEXT NOT NULL,
+    transaction_amount_cents INTEGER NOT NULL,
+    approved_amount_cents INTEGER NOT NULL,
+    merchant_category_code TEXT NOT NULL,
+    acqr_country_code TEXT NOT NULL,
+    pos_entry_mode TEXT NOT NULL,
+    merchant_id TEXT NOT NULL,
+    merchant_name TEXT NOT NULL,
+    merchant_city TEXT NOT NULL,
+    merchant_state TEXT NOT NULL,
+    merchant_zip TEXT NOT NULL,
+    transaction_id TEXT NOT NULL,
+    match_status TEXT NOT NULL,
+    auth_fraud TEXT NOT NULL,
+    fraud_rpt_date TEXT NOT NULL,
+    PRIMARY KEY(card_number, auth_timestamp)
+);
+
+CREATE TABLE IF NOT EXISTS modernization_meta (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+);
+"""
+
+
+def connect(db_path: Path) -> sqlite3.Connection:
+    conn = sqlite3.connect(str(db_path))
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA foreign_keys = ON")
+    return conn
+
+
+def initialize_schema(conn: sqlite3.Connection) -> None:
+    conn.executescript(SCHEMA)
+    conn.commit()
+
+
+def reset_database(conn: sqlite3.Connection) -> None:
+    initialize_schema(conn)
+    for table in (
+        "authorization_frauds",
+        "pending_authorization_details",
+        "pending_authorization_summaries",
+        "transactions",
+        "transaction_category_balances",
+        "card_xrefs",
+        "cards",
+        "accounts",
+        "customers",
+        "transaction_categories",
+        "transaction_types",
+        "disclosure_groups",
+        "users",
+        "modernization_meta",
+    ):
+        conn.execute(f"DELETE FROM {table}")
+    conn.commit()
+
+
+def insert_many(conn: sqlite3.Connection, table: str, rows: list[dict[str, Any]]) -> None:
+    if not rows:
+        return
+    columns = list(rows[0].keys())
+    placeholders = ", ".join("?" for _ in columns)
+    col_sql = ", ".join(columns)
+    values = [[row[column] for column in columns] for row in rows]
+    conn.executemany(f"INSERT OR REPLACE INTO {table} ({col_sql}) VALUES ({placeholders})", values)
+
+
+def seed_from_legacy(source_root: Path, db_path: Path, *, reset: bool = True) -> dict[str, int]:
+    data = source_root / "app" / "data"
+    conn = connect(db_path)
+    try:
+        if reset:
+            reset_database(conn)
+        else:
+            initialize_schema(conn)
+
+        customers = parse_ascii_file(data / "ASCII" / "custdata.txt", CUSTOMER_FIELDS, 500)
+        accounts = parse_ascii_file(data / "ASCII" / "acctdata.txt", ACCOUNT_FIELDS, 300)
+        cards = parse_ascii_file(data / "ASCII" / "carddata.txt", CARD_FIELDS, 150)
+        xrefs = parse_ascii_file(data / "ASCII" / "cardxref.txt", CARD_XREF_FIELDS, 50)
+        transactions = parse_ascii_file(data / "ASCII" / "dailytran.txt", TRANSACTION_FIELDS, 350)
+        transaction_types = parse_ascii_file(data / "ASCII" / "trantype.txt", TRANSACTION_TYPE_FIELDS, 60)
+        transaction_categories = parse_ascii_file(
+            data / "ASCII" / "trancatg.txt", TRANSACTION_CATEGORY_FIELDS, 60
+        )
+        disclosure_groups = parse_ascii_file(data / "ASCII" / "discgrp.txt", DISCLOSURE_GROUP_FIELDS, 50)
+        transaction_category_balances = parse_ascii_file(
+            data / "ASCII" / "tcatbal.txt", TRANSACTION_CATEGORY_BALANCE_FIELDS, 50
+        )
+        users = parse_user_security(data / "EBCDIC" / "AWS.M2.CARDDEMO.USRSEC.PS")
+        pending_authorizations = parse_pending_authorizations(
+            source_root
+            / "app"
+            / "app-authorization-ims-db2-mq"
+            / "data"
+            / "EBCDIC"
+            / "AWS.M2.CARDDEMO.IMSDATA.DBPAUTP0.dat"
+        )
+
+        insert_many(conn, "customers", customers)
+        insert_many(conn, "accounts", accounts)
+        insert_many(conn, "cards", cards)
+        insert_many(conn, "card_xrefs", xrefs)
+        insert_many(conn, "transactions", transactions)
+        insert_many(conn, "transaction_types", transaction_types)
+        insert_many(conn, "transaction_categories", transaction_categories)
+        insert_many(conn, "disclosure_groups", disclosure_groups)
+        insert_many(conn, "transaction_category_balances", transaction_category_balances)
+        insert_many(conn, "users", users)
+        insert_many(conn, "pending_authorization_summaries", pending_authorizations["summaries"])
+        insert_many(conn, "pending_authorization_details", pending_authorizations["details"])
+        conn.execute(
+            "INSERT OR REPLACE INTO modernization_meta(key, value) VALUES (?, ?)",
+            ("source_root", str(source_root.resolve())),
+        )
+        conn.commit()
+        return {
+            "customers": len(customers),
+            "accounts": len(accounts),
+            "cards": len(cards),
+            "card_xrefs": len(xrefs),
+            "transactions": len(transactions),
+            "transaction_types": len(transaction_types),
+            "transaction_categories": len(transaction_categories),
+            "disclosure_groups": len(disclosure_groups),
+            "transaction_category_balances": len(transaction_category_balances),
+            "users": len(users),
+            "pending_authorization_summaries": len(pending_authorizations["summaries"]),
+            "pending_authorization_details": len(pending_authorizations["details"]),
+        }
+    finally:
+        conn.close()
+
+
+def row_to_dict(row: sqlite3.Row | None) -> dict[str, Any] | None:
+    return dict(row) if row is not None else None
+
+
+def rows_to_dicts(rows: list[sqlite3.Row]) -> list[dict[str, Any]]:
+    return [dict(row) for row in rows]

modern_code/static/app.js

@@ -0,0 +1,526 @@
+const $ = (id) => document.getElementById(id);
+
+async function api(path, options = {}) {
+  const response = await fetch(path, {
+    headers: { "Content-Type": "application/json" },
+    ...options,
+  });
+  const payload = await response.json();
+  if (!response.ok) {
+    throw new Error(payload.error || response.statusText);
+  }
+  return payload;
+}
+
+function moneyCell(value) {
+  return `<span class="money">${value}</span>`;
+}
+
+function escapeHtml(value) {
+  return String(value ?? "")
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#039;");
+}
+
+function cardEditor(card, accountId) {
+  const [year, month] = String(card.expiration_date || "").split("-");
+  const suffix = String(card.card_number);
+  return `
+    <div class="account-update-editor">
+      <input id="cardName${suffix}" value="${escapeHtml(card.embossed_name)}" maxlength="50">
+      <select id="cardStatus${suffix}">
+        <option value="Y" ${card.active_status === "Y" ? "selected" : ""}>Active</option>
+        <option value="N" ${card.active_status === "N" ? "selected" : ""}>Inactive</option>
+      </select>
+      <input id="cardMonth${suffix}" value="${escapeHtml(month || "")}" maxlength="2">
+      <input id="cardYear${suffix}" value="${escapeHtml(year || "")}" maxlength="4">
+      <button onclick="updateCardDetails('${suffix}', ${accountId})">Update</button>
+    </div>
+    <div id="cardStatusMsg${suffix}"></div>
+  `;
+}
+
+let activeAccountId = null;
+
+async function loadSummary() {
+  const summary = await api("/api/summary");
+  $("claimLimit").textContent = summary.claim_limit;
+  $("summary").innerHTML = Object.entries(summary.counts)
+    .map(([key, value]) => `<div class="metric"><strong>${value}</strong>${key.replaceAll("_", " ")}</div>`)
+    .join("");
+}
+
+async function searchCustomers() {
+  const query = encodeURIComponent($("customerQuery").value);
+  const customers = await api(`/api/customers?query=${query}&limit=25`);
+  $("customers").innerHTML = customers
+    .map((customer) => `
+      <div class="row">
+        <h3>${customer.first_name} ${customer.last_name}</h3>
+        <div class="meta">Customer ${customer.customer_id} · ${customer.city || customer.address_line_3}, ${customer.state} ${customer.zip_code}</div>
+        <div class="actions">
+          <button class="secondary" onclick="loadCustomerAccounts(${customer.customer_id})">Accounts</button>
+        </div>
+      </div>
+    `)
+    .join("") || `<div class="empty">No matches.</div>`;
+}
+
+async function loadCustomerAccounts(customerId) {
+  const accounts = await api(`/api/accounts?customer_id=${customerId}`);
+  $("accountDetail").innerHTML = `
+    <div class="notice">Customer ${customerId} account results are sourced from the original CardDemo fixed-width seed files.</div>
+    <div class="list">
+      ${accounts.map((account) => `
+        <div class="row">
+          <h3>Account ${account.account_id}</h3>
+          <div class="meta">Status ${account.active_status} · balance ${account.current_balance} · limit ${account.credit_limit}</div>
+          <div class="actions"><button onclick="loadAccount(${account.account_id})">Open Workspace</button></div>
+        </div>
+      `).join("")}
+    </div>
+  `;
+}
+
+async function loadAccount(accountId) {
+  activeAccountId = accountId;
+  const bundle = await api(`/api/accounts/${accountId}`);
+  const account = bundle.account;
+  const today = new Date().toISOString().slice(0, 10);
+  $("accountDetail").innerHTML = `
+    <div class="detail-grid">
+      <div class="metric"><strong>${account.current_balance}</strong>Current balance</div>
+      <div class="metric"><strong>${account.credit_limit}</strong>Credit limit</div>
+      <div class="metric"><strong>${account.cash_credit_limit}</strong>Cash limit</div>
+    </div>
+    <div class="row">
+      <h3>Account ${account.account_id}</h3>
+      <div class="meta">Status ${account.active_status} · Open ${account.open_date} · Expires ${account.expiration_date}</div>
+      <div class="actions">
+      <input id="payAmount" placeholder="Payment dollars" value="${account.current_balance}">
+      <button onclick="makePayment(${account.account_id})">Pay Balance</button>
+      </div>
+    </div>
+    <h2>Update Account</h2>
+    <div class="account-update-editor">
+      <select id="accountStatus">
+        <option value="Y" ${account.active_status === "Y" ? "selected" : ""}>Active</option>
+        <option value="N" ${account.active_status === "N" ? "selected" : ""}>Inactive</option>
+      </select>
+      <input id="accountCreditLimit" placeholder="Credit limit" value="${account.credit_limit}">
+      <input id="accountCashLimit" placeholder="Cash limit" value="${account.cash_credit_limit}">
+      <input id="accountGroup" placeholder="Group" value="${account.group_id}" maxlength="10">
+      <button onclick="updateAccountDetails(${account.account_id})">Update</button>
+    </div>
+    <div id="accountUpdateStatus"></div>
+    <h2>Cards</h2>
+    <div class="list">
+      ${bundle.cards.map((card) => `
+        <div class="row">
+          <h3>${card.card_number}</h3>
+          ${cardEditor(card, account.account_id)}
+          <div class="meta">${card.embossed_name} · status ${card.active_status} · exp ${card.expiration_date}</div>
+        </div>
+      `).join("")}
+    </div>
+    <h2>Add Transaction</h2>
+    <div class="transaction-editor">
+      <input id="ct02Type" placeholder="Type" value="01" maxlength="2">
+      <input id="ct02Category" placeholder="Category" value="0001" maxlength="4">
+      <input id="ct02Source" placeholder="Source" value="POS TERM" maxlength="10">
+      <input id="ct02Amount" placeholder="Amount" value="+00000012.34" maxlength="12">
+      <input id="ct02OrigDate" type="date" value="${today}">
+      <input id="ct02ProcDate" type="date" value="${today}">
+      <input id="ct02MerchantId" placeholder="Merchant ID" value="123456789" maxlength="9">
+      <input id="ct02MerchantName" placeholder="Merchant" value="MODERN CARDDEMO" maxlength="30">
+      <input id="ct02MerchantCity" placeholder="City" value="SEATTLE" maxlength="25">
+      <input id="ct02MerchantZip" placeholder="ZIP" value="98101" maxlength="10">
+      <input id="ct02Description" placeholder="Description" value="Modern CT02 transaction" maxlength="60">
+      <button onclick="addCt02Transaction(${account.account_id})">Add</button>
+    </div>
+    <div id="ct02Status"></div>
+    <h2>Recent Transactions</h2>
+    <table class="table">
+      <thead><tr><th>ID</th><th>Type</th><th>Description</th><th>Merchant</th><th>Amount</th></tr></thead>
+      <tbody>
+        ${bundle.transactions.map((tran) => `
+          <tr>
+            <td>${tran.transaction_id}</td>
+            <td>${tran.type_code}/${tran.category_code}</td>
+            <td>${tran.description}</td>
+            <td>${tran.merchant_name}</td>
+            <td class="money">${tran.amount}</td>
+          </tr>
+        `).join("")}
+      </tbody>
+    </table>
+  `;
+  $("batchReports").innerHTML = `<div class="notice">Account ${accountId} selected for statement, transaction report, interest projection, and combined batch preview.</div>`;
+}
+
+async function updateAccountDetails(accountId) {
+  try {
+    const updated = await api(`/api/accounts/${accountId}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        active_status: $("accountStatus").value,
+        credit_limit_cents: Math.round(Number($("accountCreditLimit").value) * 100),
+        cash_credit_limit_cents: Math.round(Number($("accountCashLimit").value) * 100),
+        group_id: $("accountGroup").value,
+      }),
+    });
+    await loadAccount(accountId);
+    $("accountUpdateStatus").innerHTML = `<div class="notice">${escapeHtml(updated.message)}</div>`;
+    await loadSummary();
+  } catch (error) {
+    $("accountUpdateStatus").innerHTML = `<div class="notice">${escapeHtml(error.message)}</div>`;
+  }
+}
+
+async function updateCardDetails(cardNumber, accountId) {
+  const suffix = String(cardNumber);
+  try {
+    const updated = await api(`/api/cards/${encodeURIComponent(cardNumber)}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        account_id: accountId,
+        embossed_name: $(`cardName${suffix}`).value,
+        active_status: $(`cardStatus${suffix}`).value,
+        expiration_month: $(`cardMonth${suffix}`).value,
+        expiration_year: $(`cardYear${suffix}`).value,
+      }),
+    });
+    await loadAccount(accountId);
+    $(`cardStatusMsg${suffix}`).innerHTML = `<div class="notice">${escapeHtml(updated.message)}</div>`;
+    await loadSummary();
+  } catch (error) {
+    $(`cardStatusMsg${suffix}`).innerHTML = `<div class="notice">${escapeHtml(error.message)}</div>`;
+  }
+}
+
+async function addCt02Transaction(accountId) {
+  try {
+    const transaction = await api("/api/transactions", {
+      method: "POST",
+      body: JSON.stringify({
+        account_id: accountId,
+        type_code: $("ct02Type").value,
+        category_code: $("ct02Category").value,
+        source: $("ct02Source").value,
+        description: $("ct02Description").value,
+        amount: $("ct02Amount").value,
+        original_timestamp: $("ct02OrigDate").value,
+        processed_timestamp: $("ct02ProcDate").value,
+        merchant_id: $("ct02MerchantId").value,
+        merchant_name: $("ct02MerchantName").value,
+        merchant_city: $("ct02MerchantCity").value,
+        merchant_zip: $("ct02MerchantZip").value,
+        confirm: "Y",
+      }),
+    });
+    await loadAccount(accountId);
+    $("ct02Status").innerHTML = `<div class="notice">${escapeHtml(transaction.message)}</div>`;
+  } catch (error) {
+    $("ct02Status").innerHTML = `<div class="notice">${escapeHtml(error.message)}</div>`;
+  }
+}
+
+async function makePayment(accountId) {
+  const raw = $("payAmount").value.trim();
+  const cents = Math.round(Number(raw) * 100);
+  await api("/api/bill-payments", {
+    method: "POST",
+    body: JSON.stringify({ account_id: accountId, amount_cents: cents }),
+  });
+  await loadAccount(accountId);
+  await loadSummary();
+}
+
+function needAccount() {
+  if (!activeAccountId) {
+    $("batchReports").innerHTML = `<div class="empty">Select an account first.</div>`;
+    return false;
+  }
+  return true;
+}
+
+async function loadStatement() {
+  if (!needAccount()) return;
+  const statement = await api(`/api/statements/${activeAccountId}`);
+  $("batchReports").innerHTML = `
+    <div class="detail-grid">
+      <div class="metric"><strong>${statement.transaction_count}</strong>Transactions</div>
+      <div class="metric"><strong>${statement.total_expense}</strong>Total EXP</div>
+      <div class="metric"><strong>${statement.legacy_job}</strong>Legacy job</div>
+    </div>
+    <div class="statement-lines">${statement.plain_text_lines.join("\n")}</div>
+  `;
+}
+
+async function loadTransactionReport() {
+  if (!needAccount()) return;
+  const report = await api(`/api/reports/transactions?account_id=${activeAccountId}&limit=1000`);
+  $("batchReports").innerHTML = `
+    <div class="detail-grid">
+      <div class="metric"><strong>${report.totals.transaction_count}</strong>Rows</div>
+      <div class="metric"><strong>${report.totals.total_amount}</strong>Total</div>
+      <div class="metric"><strong>${report.legacy_job}</strong>Legacy job</div>
+    </div>
+    <table class="table">
+      <thead><tr><th>ID</th><th>Date</th><th>Type</th><th>Description</th><th>Amount</th></tr></thead>
+      <tbody>
+        ${report.rows.slice(0, 25).map((tran) => `
+          <tr>
+            <td>${tran.transaction_id}</td>
+            <td>${tran.processed_timestamp.slice(0, 10)}</td>
+            <td>${tran.type_code}/${tran.category_code}</td>
+            <td>${tran.description}</td>
+            <td class="money">${tran.amount}</td>
+          </tr>
+        `).join("")}
+      </tbody>
+    </table>
+  `;
+}
+
+async function loadInterest() {
+  const projection = await api("/api/interest-projection?limit=1000");
+  $("batchReports").innerHTML = `
+    <div class="detail-grid">
+      <div class="metric"><strong>${projection.totals.account_count}</strong>Accounts</div>
+      <div class="metric"><strong>${projection.totals.total_interest}</strong>Total Interest</div>
+      <div class="metric"><strong>${projection.legacy_job}</strong>Legacy job</div>
+    </div>
+    <table class="table">
+      <thead><tr><th>Account</th><th>Categories</th><th>Generated Amount</th></tr></thead>
+      <tbody>
+        ${projection.account_totals.slice(0, 25).map((row) => `
+          <tr>
+            <td>${row.account_id}</td>
+            <td>${row.category_count}</td>
+            <td class="money">${row.total_interest}</td>
+          </tr>
+        `).join("")}
+      </tbody>
+    </table>
+  `;
+}
+
+async function loadCombined() {
+  const combined = await api("/api/batch/combined-transactions?limit=40");
+  $("batchReports").innerHTML = `
+    <div class="detail-grid">
+      <div class="metric"><strong>${combined.source_counts.transaction_master}</strong>Seed tx</div>
+      <div class="metric"><strong>${combined.source_counts.interest_projection}</strong>Interest tx</div>
+      <div class="metric"><strong>${combined.legacy_job}</strong>Legacy job</div>
+    </div>
+    <table class="table">
+      <thead><tr><th>ID</th><th>Source</th><th>Card</th><th>Date</th><th>Amount</th></tr></thead>
+      <tbody>
+        ${combined.rows.map((row) => `
+          <tr>
+            <td>${row.transaction_id}</td>
+            <td>${row.combine_source}</td>
+            <td>${row.card_number}</td>
+            <td>${row.processed_timestamp.slice(0, 10)}</td>
+            <td class="money">${row.amount}</td>
+          </tr>
+        `).join("")}
+      </tbody>
+    </table>
+  `;
+}
+
+function renderMenu(menu) {
+  return `
+    <div class="detail-grid">
+      <div class="metric"><strong>${escapeHtml(menu.legacy_transaction)}</strong>Transaction</div>
+      <div class="metric"><strong>${escapeHtml(menu.legacy_program)}</strong>Program</div>
+      <div class="metric"><strong>${menu.option_count}</strong>Options</div>
+    </div>
+    <table class="table">
+      <thead><tr><th>#</th><th>Option</th><th>Program</th><th>Tx</th></tr></thead>
+      <tbody>
+        ${menu.options.map((row) => `
+          <tr>
+            <td>${row.option}</td>
+            <td>${escapeHtml(row.name)}</td>
+            <td>${escapeHtml(row.program)}</td>
+            <td>${escapeHtml(row.transaction)}</td>
+          </tr>
+        `).join("")}
+      </tbody>
+    </table>
+  `;
+}
+
+async function signOn() {
+  const result = await api("/api/signon", {
+    method: "POST",
+    body: JSON.stringify({
+      user_id: $("signonUser").value,
+      password: $("signonPassword").value,
+    }),
+  });
+  if (!result.authenticated) {
+    $("securityDetail").innerHTML = `<div class="notice">${escapeHtml(result.message)}</div>`;
+    return;
+  }
+  $("securityDetail").innerHTML = `
+    <div class="notice">${escapeHtml(result.user.user_id)} routed to ${escapeHtml(result.route_transaction)} / ${escapeHtml(result.route_program)}</div>
+    ${renderMenu(result.menu)}
+  `;
+}
+
+function userPayload() {
+  return {
+    user_id: $("userId").value,
+    first_name: $("userFirstName").value,
+    last_name: $("userLastName").value,
+    password: $("userPassword").value,
+    user_type: $("userType").value,
+  };
+}
+
+function fillUser(user) {
+  $("userId").value = user.user_id;
+  $("userFirstName").value = user.first_name;
+  $("userLastName").value = user.last_name;
+  $("userPassword").value = user.password;
+  $("userType").value = user.user_type;
+}
+
+async function loadUser(userId) {
+  const user = await api(`/api/users/${encodeURIComponent(userId)}`);
+  fillUser(user);
+}
+
+async function loadUsers() {
+  const users = await api("/api/users");
+  $("securityDetail").innerHTML = `
+    <table class="table">
+      <thead><tr><th>User</th><th>Name</th><th>Type</th><th></th></tr></thead>
+      <tbody>
+        ${users.map((user) => `
+          <tr>
+            <td>${escapeHtml(user.user_id)}</td>
+            <td>${escapeHtml(user.first_name)} ${escapeHtml(user.last_name)}</td>
+            <td>${escapeHtml(user.user_type)}</td>
+            <td><button class="secondary" onclick="loadUser('${escapeHtml(user.user_id)}')">Edit</button></td>
+          </tr>
+        `).join("")}
+      </tbody>
+    </table>
+  `;
+}
+
+async function addUser() {
+  const result = await api("/api/users", {
+    method: "POST",
+    body: JSON.stringify(userPayload()),
+  });
+  $("securityDetail").innerHTML = `<div class="notice">${escapeHtml(result.message)}</div>`;
+  await loadUsers();
+  await loadSummary();
+}
+
+async function updateUser() {
+  const payload = userPayload();
+  const result = await api(`/api/users/${encodeURIComponent(payload.user_id)}`, {
+    method: "PATCH",
+    body: JSON.stringify(payload),
+  });
+  $("securityDetail").innerHTML = `<div class="notice">${escapeHtml(result.message)}</div>`;
+  await loadUsers();
+}
+
+async function deleteUser() {
+  const userId = $("userId").value.trim();
+  const result = await api(`/api/users/${encodeURIComponent(userId)}`, { method: "DELETE" });
+  $("securityDetail").innerHTML = `<div class="notice">${escapeHtml(result.message)}</div>`;
+  await loadUsers();
+  await loadSummary();
+}
+
+function transactionTypePayload() {
+  return {
+    type_code: $("typeCode").value,
+    description: $("typeDescription").value,
+  };
+}
+
+function fillTransactionType(type) {
+  $("typeCode").value = type.type_code;
+  $("typeDescription").value = type.description;
+}
+
+function renderTransactionTypes(catalog, status = "") {
+  $("transactionTypeDetail").innerHTML = `
+    ${status ? `<div class="notice">${escapeHtml(status)}</div>` : ""}
+    <table class="table">
+      <thead><tr><th>Type</th><th>Description</th><th></th></tr></thead>
+      <tbody>
+        ${catalog.types.map((type) => `
+          <tr>
+            <td>${escapeHtml(type.type_code)}</td>
+            <td>${escapeHtml(type.description)}</td>
+            <td><button class="secondary" onclick="fillTransactionType({ type_code: '${escapeHtml(type.type_code)}', description: '${escapeHtml(type.description)}' })">Edit</button></td>
+          </tr>
+        `).join("")}
+      </tbody>
+    </table>
+  `;
+}
+
+async function loadTransactionTypes(status = "") {
+  const catalog = await api("/api/transaction-types");
+  renderTransactionTypes(catalog, status);
+}
+
+async function saveTransactionType() {
+  const result = await api("/api/transaction-types", {
+    method: "POST",
+    body: JSON.stringify(transactionTypePayload()),
+  });
+  await loadTransactionTypes(`${result.message} (${result.action} ${result.type_code})`);
+  await loadSummary();
+}
+
+async function deleteTransactionType() {
+  const typeCode = $("typeCode").value.trim();
+  const result = await api(`/api/transaction-types/${encodeURIComponent(typeCode)}`, { method: "DELETE" });
+  await loadTransactionTypes(result.message);
+  await loadSummary();
+}
+
+function showSecurityError(error) {
+  $("securityDetail").innerHTML = `<div class="notice">${escapeHtml(error.message)}</div>`;
+}
+
+function showTransactionTypeError(error) {
+  $("transactionTypeDetail").innerHTML = `<div class="notice">${escapeHtml(error.message)}</div>`;
+}
+
+$("refreshBtn").addEventListener("click", () => {
+  loadSummary();
+  searchCustomers();
+});
+$("searchBtn").addEventListener("click", searchCustomers);
+$("statementBtn").addEventListener("click", loadStatement);
+$("transactionReportBtn").addEventListener("click", loadTransactionReport);
+$("interestBtn").addEventListener("click", loadInterest);
+$("combinedBtn").addEventListener("click", loadCombined);
+$("signonBtn").addEventListener("click", () => signOn().catch(showSecurityError));
+$("usersBtn").addEventListener("click", () => loadUsers().catch(showSecurityError));
+$("addUserBtn").addEventListener("click", () => addUser().catch(showSecurityError));
+$("updateUserBtn").addEventListener("click", () => updateUser().catch(showSecurityError));
+$("deleteUserBtn").addEventListener("click", () => deleteUser().catch(showSecurityError));
+$("typesBtn").addEventListener("click", () => loadTransactionTypes().catch(showTransactionTypeError));
+$("saveTypeBtn").addEventListener("click", () => saveTransactionType().catch(showTransactionTypeError));
+$("deleteTypeBtn").addEventListener("click", () => deleteTransactionType().catch(showTransactionTypeError));
+
+loadSummary();
+searchCustomers();

modern_code/static/index.html

@@ -0,0 +1,84 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Modern CardDemo</title>
+    <link rel="stylesheet" href="/static/styles.css">
+  </head>
+  <body>
+    <header class="topbar">
+      <div>
+        <h1>Modern CardDemo</h1>
+        <p id="claimLimit">Loading modernization claim limits...</p>
+      </div>
+      <button id="refreshBtn">Refresh</button>
+    </header>
+
+    <main class="layout">
+      <section class="panel">
+        <h2>Portfolio</h2>
+        <div id="summary" class="metrics"></div>
+      </section>
+
+      <section class="panel">
+        <h2>Customer Search</h2>
+        <div class="searchbar">
+          <input id="customerQuery" placeholder="Name, customer id, or ZIP" value="Kessler">
+          <button id="searchBtn">Search</button>
+        </div>
+        <div id="customers" class="list"></div>
+      </section>
+
+      <section class="panel wide">
+        <h2>Account Workspace</h2>
+        <div id="accountDetail" class="detail empty">Select a customer/account.</div>
+      </section>
+
+      <section class="panel wide">
+        <h2>Batch Reports</h2>
+        <div class="actions report-actions">
+          <button id="statementBtn">Statement</button>
+          <button id="transactionReportBtn" class="secondary">Transactions</button>
+          <button id="interestBtn" class="secondary">Interest</button>
+          <button id="combinedBtn" class="secondary">Combined</button>
+        </div>
+        <div id="batchReports" class="detail empty">Open an account, then choose a report.</div>
+      </section>
+
+      <section class="panel wide">
+        <h2>Security</h2>
+        <div class="security-grid">
+          <input id="signonUser" placeholder="User ID" value="ADMIN001">
+          <input id="signonPassword" placeholder="Password" value="PASSWORD" type="password">
+          <button id="signonBtn">Sign On</button>
+        </div>
+        <div class="user-editor">
+          <input id="userId" placeholder="User ID" maxlength="8">
+          <input id="userFirstName" placeholder="First name" maxlength="20">
+          <input id="userLastName" placeholder="Last name" maxlength="20">
+          <input id="userPassword" placeholder="Password" maxlength="8" type="password">
+          <select id="userType">
+            <option value="U">User</option>
+            <option value="A">Admin</option>
+          </select>
+          <button id="addUserBtn">Add</button>
+          <button id="updateUserBtn" class="secondary">Update</button>
+          <button id="deleteUserBtn" class="secondary">Delete</button>
+          <button id="usersBtn" class="secondary">Users</button>
+        </div>
+        <div class="type-editor">
+          <input id="typeCode" placeholder="Type code" maxlength="2">
+          <input id="typeDescription" placeholder="Description" maxlength="50">
+          <button id="saveTypeBtn">Save Type</button>
+          <button id="deleteTypeBtn" class="secondary">Delete Type</button>
+          <button id="typesBtn" class="secondary">Types</button>
+        </div>
+        <div id="securityDetail" class="detail empty">Sign on or load users.</div>
+        <div id="transactionTypeDetail" class="detail empty">Load transaction types or save a type.</div>
+      </section>
+    </main>
+
+    <script src="/static/app.js"></script>
+  </body>
+</html>

modern_code/static/styles.css

@@ -0,0 +1,253 @@
+:root {
+  color-scheme: light;
+  --ink: #20242c;
+  --muted: #637083;
+  --line: #d7dce3;
+  --panel: #ffffff;
+  --page: #f5f7f8;
+  --accent: #146b5f;
+  --accent-2: #405c9a;
+  --warn: #8b5a00;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+  font-family: Arial, Helvetica, sans-serif;
+  color: var(--ink);
+  background: var(--page);
+}
+
+.topbar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 24px;
+  padding: 18px 24px;
+  background: #ffffff;
+  border-bottom: 1px solid var(--line);
+}
+
+h1,
+h2,
+h3 {
+  margin: 0;
+  font-weight: 700;
+}
+
+h1 {
+  font-size: 24px;
+}
+
+h2 {
+  font-size: 16px;
+  margin-bottom: 12px;
+}
+
+p {
+  margin: 6px 0 0;
+  color: var(--muted);
+}
+
+button {
+  border: 1px solid var(--accent);
+  background: var(--accent);
+  color: white;
+  padding: 8px 12px;
+  border-radius: 6px;
+  cursor: pointer;
+}
+
+button.secondary {
+  background: #ffffff;
+  color: var(--accent);
+}
+
+input,
+select {
+  border: 1px solid var(--line);
+  padding: 8px;
+  border-radius: 6px;
+  min-width: 0;
+}
+
+.layout {
+  display: grid;
+  grid-template-columns: minmax(220px, 320px) minmax(280px, 380px) minmax(460px, 1fr);
+  gap: 16px;
+  padding: 16px;
+}
+
+.panel {
+  background: var(--panel);
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  padding: 16px;
+  min-height: 120px;
+}
+
+.wide {
+  min-height: 520px;
+  grid-column: span 1;
+}
+
+.metrics {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 10px;
+}
+
+.metric {
+  border: 1px solid var(--line);
+  border-radius: 6px;
+  padding: 10px;
+}
+
+.metric strong {
+  display: block;
+  font-size: 20px;
+  color: var(--accent-2);
+}
+
+.searchbar {
+  display: grid;
+  grid-template-columns: 1fr auto;
+  gap: 8px;
+  margin-bottom: 12px;
+}
+
+.list {
+  display: grid;
+  gap: 8px;
+}
+
+.row {
+  border: 1px solid var(--line);
+  border-radius: 6px;
+  padding: 10px;
+  background: #fbfcfd;
+}
+
+.row h3 {
+  font-size: 14px;
+}
+
+.row .meta,
+.detail .meta {
+  color: var(--muted);
+  font-size: 12px;
+  margin-top: 4px;
+}
+
+.actions {
+  display: flex;
+  gap: 8px;
+  flex-wrap: wrap;
+  margin-top: 10px;
+}
+
+.detail-grid {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 12px;
+  margin-bottom: 14px;
+}
+
+.table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 13px;
+}
+
+.table th,
+.table td {
+  border-bottom: 1px solid var(--line);
+  padding: 7px;
+  text-align: left;
+  vertical-align: top;
+}
+
+.money {
+  font-variant-numeric: tabular-nums;
+  text-align: right;
+}
+
+.empty {
+  color: var(--muted);
+}
+
+.notice {
+  border-left: 4px solid var(--warn);
+  padding: 8px 10px;
+  background: #fff8e8;
+  margin-bottom: 12px;
+  color: #453000;
+}
+
+.report-actions {
+  margin-bottom: 12px;
+}
+
+.security-grid,
+.user-editor,
+.account-update-editor,
+.type-editor,
+.transaction-editor {
+  display: grid;
+  gap: 8px;
+  margin-bottom: 12px;
+}
+
+.security-grid {
+  grid-template-columns: minmax(120px, 1fr) minmax(120px, 1fr) auto;
+}
+
+.user-editor {
+  grid-template-columns: repeat(5, minmax(90px, 1fr)) repeat(4, auto);
+}
+
+.account-update-editor {
+  grid-template-columns: repeat(4, minmax(90px, 1fr)) auto;
+}
+
+.type-editor {
+  grid-template-columns: minmax(80px, 120px) minmax(180px, 1fr) repeat(3, auto);
+}
+
+.transaction-editor {
+  grid-template-columns: repeat(6, minmax(90px, 1fr));
+}
+
+.transaction-editor button {
+  min-width: 80px;
+}
+
+.statement-lines {
+  max-height: 380px;
+  overflow: auto;
+  white-space: pre-wrap;
+  font-family: Consolas, "Courier New", monospace;
+  font-size: 12px;
+  line-height: 1.45;
+  border: 1px solid var(--line);
+  border-radius: 6px;
+  padding: 10px;
+  background: #fbfcfd;
+}
+
+@media (max-width: 1000px) {
+  .layout {
+    grid-template-columns: 1fr;
+  }
+
+  .security-grid,
+  .user-editor,
+  .account-update-editor,
+  .type-editor,
+  .transaction-editor {
+    grid-template-columns: 1fr;
+  }
+}

modern_code/tests/test_a_grade_promotion.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+from tools.evaluate_a_grade_promotion import SOURCE_HEAD, build_a_grade_report
+
+
+MODERN_ROOT = Path(__file__).resolve().parents[1]
+SOURCE = Path(__file__).resolve().parents[2] / "source"
+
+
+class AGradePromotionTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        required_reports = [
+            MODERN_ROOT / "reports" / "capability_ledger.json",
+            MODERN_ROOT / "reports" / "modernization_receipt.json",
+        ]
+        if all(path.exists() for path in required_reports):
+            return
+        subprocess.run(
+            [
+                sys.executable,
+                str(MODERN_ROOT / "tools" / "generate_receipts.py"),
+                "--source-root",
+                str(SOURCE),
+                "--db-path",
+                str(MODERN_ROOT / "carddemo.sqlite"),
+                "--out-dir",
+                str(MODERN_ROOT / "reports"),
+            ],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+
+    def test_gate_does_not_promote_without_live_legacy_trace_corpus(self) -> None:
+        report = build_a_grade_report(MODERN_ROOT, SOURCE)
+
+        self.assertFalse(report["a_grade_gate"]["promotable_to_A"])
+        self.assertEqual(50, report["a_grade_gate"]["required_live_matches"])
+        self.assertEqual(0, report["a_grade_gate"]["accepted_live_matches"])
+        self.assertEqual(50, report["a_grade_gate"]["missing_live_matches"])
+        self.assertEqual(50, report["current_static_source_oracle_status"]["grade_counts"]["B"])
+        self.assertEqual(0, report["current_static_source_oracle_status"]["grade_counts"]["F"])
+        self.assertEqual(0, report["current_static_source_oracle_status"]["gap_count"])
+        self.assertTrue(
+            any(blocker["code"] == "missing_live_legacy_trace_corpus" for blocker in report["blockers"])
+        )
+
+    def test_gate_accepts_only_contract_compliant_live_trace_records(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            trace_dir = Path(tmp)
+            partial_trace = {
+                "capability_matches": [
+                    {
+                        "capability_id": "online:CC00",
+                        "trace_kind": "live_cobol_cics_runtime",
+                        "source_head": SOURCE_HEAD,
+                        "legacy_runtime_environment": "unit-test-mainframe-runtime",
+                        "raw_legacy_trace_hash": "a" * 64,
+                        "modern_observation_hash": "b" * 64,
+                        "comparator_version": "unit-test",
+                        "matched": True,
+                    },
+                    {
+                        "capability_id": "online:CC01",
+                        "trace_kind": "static_oracle_replay",
+                        "source_head": SOURCE_HEAD,
+                        "legacy_runtime_environment": "not-live-runtime",
+                        "raw_legacy_trace_hash": "c" * 64,
+                        "modern_observation_hash": "d" * 64,
+                        "comparator_version": "unit-test",
+                        "matched": True,
+                    },
+                ]
+            }
+            (trace_dir / "partial_trace.json").write_text(json.dumps(partial_trace), encoding="utf-8")
+
+            report = build_a_grade_report(MODERN_ROOT, SOURCE, trace_dir)
+
+            self.assertFalse(report["a_grade_gate"]["promotable_to_A"])
+            self.assertEqual(1, report["a_grade_gate"]["accepted_live_matches"])
+            self.assertEqual(49, report["a_grade_gate"]["missing_live_matches"])
+            self.assertIn("online:CC00", report["live_trace_scan"]["accepted_matches"])
+            rejected_ids = {item.get("capability_id") for item in report["live_trace_scan"]["rejected_records"]}
+            self.assertIn("online:CC01", rejected_ids)
+
+
+if __name__ == "__main__":
+    unittest.main()

modern_code/tests/test_hf_public_bundle.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+from tools.build_hf_public_bundle import SOURCE_HEAD, build_bundle
+
+
+MODERN_ROOT = Path(__file__).resolve().parents[1]
+SOURCE = Path(__file__).resolve().parents[2] / "source"
+
+
+class HfPublicBundleTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        required = [
+            MODERN_ROOT / "final_proof" / "FINAL_RECEIPT_SUMMARY.json",
+            MODERN_ROOT / "final_proof" / "NO_COST_CONFIDENCE_REPORT.json",
+            MODERN_ROOT / "final_proof" / "A_GRADE_PROMOTION_REPORT.json",
+        ]
+        if all(path.exists() for path in required):
+            return
+        commands = [
+            [
+                sys.executable,
+                "-m",
+                "carddemo.cli",
+                "init-db",
+                "--source-root",
+                str(SOURCE),
+                "--db-path",
+                str(MODERN_ROOT / "carddemo.sqlite"),
+            ],
+            [
+                sys.executable,
+                str(MODERN_ROOT / "tools" / "generate_receipts.py"),
+                "--source-root",
+                str(SOURCE),
+                "--db-path",
+                str(MODERN_ROOT / "carddemo.sqlite"),
+                "--out-dir",
+                str(MODERN_ROOT / "reports"),
+            ],
+            [
+                sys.executable,
+                str(MODERN_ROOT / "tools" / "replay_static_oracles.py"),
+                "--source-root",
+                str(SOURCE),
+                "--out-dir",
+                str(MODERN_ROOT / "reports"),
+                "--source-head",
+                SOURCE_HEAD,
+            ],
+            [
+                sys.executable,
+                str(MODERN_ROOT / "tools" / "evaluate_a_grade_promotion.py"),
+                "--source-root",
+                str(SOURCE),
+                "--out-dir",
+                str(MODERN_ROOT / "final_proof"),
+            ],
+            [
+                sys.executable,
+                str(MODERN_ROOT / "tools" / "build_no_cost_confidence.py"),
+                "--source-root",
+                str(SOURCE),
+                "--out-dir",
+                str(MODERN_ROOT / "final_proof"),
+            ],
+            [
+                sys.executable,
+                str(MODERN_ROOT / "tools" / "package_final_proof.py"),
+                "--source-root",
+                str(SOURCE),
+            ],
+        ]
+        for command in commands:
+            subprocess.run(command, check=True, capture_output=True, text=True, cwd=MODERN_ROOT)
+
+    def test_public_bundle_has_disclaimers_and_excludes_upstream_source_tree(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            out_dir = Path(tmp) / "hf_bundle"
+            manifest = build_bundle(MODERN_ROOT, out_dir, "cjc0013/aws-carddemo-no-cost-modernization-proof")
+            readme = (out_dir / "README.md").read_text(encoding="utf-8")
+            all_paths = {item["path"] for item in manifest["files"]}
+
+            self.assertIn(SOURCE_HEAD, readme)
+            self.assertIn("not a claim of live COBOL/CICS all-path runtime equivalence", readme)
+            self.assertIn("without paid/licensed legacy runtime", readme)
+            self.assertFalse(any(path.startswith("source/") for path in all_paths))
+            self.assertFalse(any("/app/cbl/" in path or path.startswith("app/cbl/") for path in all_paths))
+            self.assertIn("final_proof/NO_COST_CONFIDENCE_REPORT.json", all_paths)
+            self.assertIn("modern_code/tools/build_hf_public_bundle.py", all_paths)
+            self.assertFalse(manifest["public_safe_checks"]["original_source_tree_copied"])
+            self.assertFalse(manifest["public_safe_checks"]["live_runtime_equivalence_claim_made"])
+
+
+if __name__ == "__main__":
+    unittest.main()

modern_code/tests/test_legacy_parser.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import unittest
+from pathlib import Path
+
+from carddemo.legacy_parser import (
+    ACCOUNT_FIELDS,
+    CUSTOMER_FIELDS,
+    TRANSACTION_FIELDS,
+    parse_ascii_file,
+    parse_overpunch_int,
+    parse_pending_authorizations,
+    parse_user_security,
+)
+
+
+ROOT = Path(__file__).resolve().parents[2]
+SOURCE = ROOT / "source"
+
+
+class LegacyParserTests(unittest.TestCase):
+    def test_overpunch_money_signs(self) -> None:
+        self.assertEqual(parse_overpunch_int("00000001940{"), 19400)
+        self.assertEqual(parse_overpunch_int("0000005047G"), 50477)
+        self.assertEqual(parse_overpunch_int("0000009190}"), -91900)
+
+    def test_customer_record_layout(self) -> None:
+        rows = parse_ascii_file(SOURCE / "app" / "data" / "ASCII" / "custdata.txt", CUSTOMER_FIELDS, 500)
+        self.assertEqual(len(rows), 50)
+        self.assertEqual(rows[0]["customer_id"], 1)
+        self.assertEqual(rows[0]["first_name"], "Immanuel")
+        self.assertEqual(rows[0]["last_name"], "Kessler")
+
+    def test_account_record_layout(self) -> None:
+        rows = parse_ascii_file(SOURCE / "app" / "data" / "ASCII" / "acctdata.txt", ACCOUNT_FIELDS, 300)
+        self.assertEqual(len(rows), 50)
+        self.assertEqual(rows[0]["account_id"], 1)
+        self.assertEqual(rows[0]["current_balance_cents"], 19400)
+        self.assertEqual(rows[0]["credit_limit_cents"], 202000)
+
+    def test_transaction_record_layout(self) -> None:
+        rows = parse_ascii_file(SOURCE / "app" / "data" / "ASCII" / "dailytran.txt", TRANSACTION_FIELDS, 350)
+        self.assertEqual(len(rows), 300)
+        self.assertEqual(rows[0]["type_code"], "01")
+        self.assertEqual(rows[0]["amount_cents"], 50477)
+        self.assertEqual(rows[1]["amount_cents"], -91900)
+
+    def test_user_security_decodes_ebcdic(self) -> None:
+        users = parse_user_security(SOURCE / "app" / "data" / "EBCDIC" / "AWS.M2.CARDDEMO.USRSEC.PS")
+        self.assertEqual(len(users), 10)
+        self.assertEqual(users[0]["user_id"], "ADMIN001")
+        self.assertEqual(users[0]["user_type"], "A")
+
+    def test_pending_authorization_ims_unload_decodes_segments(self) -> None:
+        parsed = parse_pending_authorizations(
+            SOURCE
+            / "app"
+            / "app-authorization-ims-db2-mq"
+            / "data"
+            / "EBCDIC"
+            / "AWS.M2.CARDDEMO.IMSDATA.DBPAUTP0.dat"
+        )
+        self.assertEqual(len(parsed["summaries"]), 21)
+        self.assertEqual(len(parsed["details"]), 202)
+        self.assertEqual(parsed["summaries"][0]["account_id"], 1)
+        self.assertEqual(parsed["summaries"][0]["approved_auth_count"], 6)
+        self.assertEqual(parsed["details"][0]["card_number"], "9680294154603697")
+        self.assertEqual(parsed["details"][0]["auth_orig_date"], "231027")
+        self.assertEqual(parsed["details"][0]["auth_resp_code"], "00")
+
+
+if __name__ == "__main__":
+    unittest.main()

modern_code/tests/test_no_cost_confidence.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+import unittest
+from pathlib import Path
+
+from tools.build_no_cost_confidence import SOURCE_HEAD, build_no_cost_confidence_report
+
+
+MODERN_ROOT = Path(__file__).resolve().parents[1]
+SOURCE = Path(__file__).resolve().parents[2] / "source"
+
+
+class NoCostConfidenceTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "carddemo.cli",
+                "init-db",
+                "--source-root",
+                str(SOURCE),
+                "--db-path",
+                str(MODERN_ROOT / "carddemo.sqlite"),
+            ],
+            check=True,
+            capture_output=True,
+            text=True,
+            cwd=MODERN_ROOT,
+        )
+        subprocess.run(
+            [
+                sys.executable,
+                str(MODERN_ROOT / "tools" / "generate_receipts.py"),
+                "--source-root",
+                str(SOURCE),
+                "--db-path",
+                str(MODERN_ROOT / "carddemo.sqlite"),
+                "--out-dir",
+                str(MODERN_ROOT / "reports"),
+            ],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        subprocess.run(
+            [
+                sys.executable,
+                str(MODERN_ROOT / "tools" / "replay_static_oracles.py"),
+                "--source-root",
+                str(SOURCE),
+                "--out-dir",
+                str(MODERN_ROOT / "reports"),
+                "--source-head",
+                SOURCE_HEAD,
+            ],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        subprocess.run(
+            [
+                sys.executable,
+                str(MODERN_ROOT / "tools" / "evaluate_a_grade_promotion.py"),
+                "--source-root",
+                str(SOURCE),
+                "--out-dir",
+                str(MODERN_ROOT / "final_proof"),
+            ],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+
+    def test_no_cost_report_keeps_runtime_boundary_honest(self) -> None:
+        report = build_no_cost_confidence_report(MODERN_ROOT, SOURCE, MODERN_ROOT / "final_proof")
+
+        self.assertFalse(report["no_cost_scope"]["paid_runtime_used"])
+        self.assertFalse(report["no_cost_scope"]["legacy_runtime_claim_made"])
+        self.assertEqual("strong_pre_runtime_confidence", report["no_cost_confidence_summary"]["reviewer_posture"])
+        self.assertEqual(50, report["capability_coverage"]["capability_count"])
+        self.assertEqual(50, report["capability_coverage"]["static_oracle_ready_count"])
+        self.assertEqual(50, report["a_grade_gate"]["missing_live_matches"])
+        self.assertFalse(report["a_grade_gate"]["promotable_to_A"])
+
+    def test_source_semantics_scan_names_why_free_runtime_is_limited(self) -> None:
+        report = build_no_cost_confidence_report(MODERN_ROOT, SOURCE, MODERN_ROOT / "final_proof")
+        scan = report["legacy_source_semantics_scan"]
+
+        self.assertGreaterEqual(scan["cobol_program_count"], 30)
+        self.assertGreater(scan["cics_program_count"], 0)
+        self.assertGreater(scan["free_gnucobol_probe_candidate_count"], 0)
+        self.assertGreater(scan["runtime_required_program_count"], 0)
+        self.assertIn("CICS/VSAM/JCL", report["no_cost_confidence_summary"]["remaining_gap"])
+
+
+if __name__ == "__main__":
+    unittest.main()

modern_code/tests/test_parity.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+from carddemo.parity import build_capability_ledger, build_parity_evidence
+from carddemo.repository import seed_from_legacy
+
+
+ROOT = Path(__file__).resolve().parents[2]
+SOURCE = ROOT / "source"
+
+
+class ParityEvidenceTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.tmp = tempfile.TemporaryDirectory()
+        self.db_path = Path(self.tmp.name) / "carddemo.sqlite"
+        seed_from_legacy(SOURCE, self.db_path, reset=True)
+
+    def tearDown(self) -> None:
+        self.tmp.cleanup()
+
+    def test_capability_ledger_covers_readme_inventory(self) -> None:
+        ledger = build_capability_ledger(SOURCE)
+        self.assertEqual(len(ledger), 50)
+        by_id = {row["capability_id"]: row for row in ledger}
+        self.assertEqual(by_id["online:CAVW"]["proof_grade"], "B")
+        self.assertEqual(by_id["online:CP00"]["proof_grade"], "B")
+        self.assertEqual(by_id["online:CPVS"]["proof_grade"], "B")
+        self.assertEqual(by_id["online:CPVD"]["proof_grade"], "B")
+        self.assertEqual(by_id["online:CC00"]["proof_grade"], "B")
+        self.assertEqual(by_id["online:CM00"]["proof_grade"], "B")
+        self.assertEqual(by_id["online:CA00"]["proof_grade"], "B")
+        self.assertEqual(by_id["online:CAUP"]["proof_grade"], "B")
+        self.assertEqual(by_id["online:CCDL"]["proof_grade"], "B")
+        self.assertEqual(by_id["online:CCUP"]["proof_grade"], "B")
+        self.assertEqual(by_id["online:CU01"]["proof_grade"], "B")
+        self.assertEqual(by_id["online:CU02"]["proof_grade"], "B")
+        self.assertEqual(by_id["online:CU03"]["proof_grade"], "B")
+        self.assertEqual(by_id["online:CT02"]["proof_grade"], "B")
+        self.assertEqual(by_id["online:CTLI"]["proof_grade"], "B")
+        self.assertEqual(by_id["online:CTTU"]["proof_grade"], "B")
+        self.assertEqual(by_id["batch:INTCALC"]["proof_grade"], "B")
+        self.assertEqual(by_id["batch:POSTTRAN"]["proof_grade"], "B")
+        self.assertEqual(by_id["online:CB00"]["proof_grade"], "B")
+        self.assertEqual(by_id["batch:TRANREPT"]["proof_grade"], "B")
+        self.assertEqual(by_id["batch:COMBTRAN"]["proof_grade"], "B")
+        self.assertEqual(by_id["batch:CREASTMT"]["proof_grade"], "B")
+        self.assertEqual(by_id["batch:MNTTRDB2"]["proof_grade"], "B")
+        self.assertEqual(by_id["batch:TRANBKP"]["proof_grade"], "B")
+        self.assertEqual(by_id["batch:TRANEXTR"]["proof_grade"], "B")
+        self.assertEqual(by_id["batch:CREADB21"]["proof_grade"], "B")
+        self.assertEqual(by_id["batch:CBPAUP0J"]["proof_grade"], "B")
+        self.assertEqual(by_id["online:CDRD"]["proof_grade"], "B")
+        self.assertEqual(by_id["online:CDRA"]["proof_grade"], "B")
+        self.assertEqual(by_id["batch:DEFGDGB"]["proof_grade"], "B")
+        self.assertEqual(by_id["batch:DEFGDGD"]["proof_grade"], "B")
+        self.assertEqual(by_id["batch:ESDSRRDS"]["proof_grade"], "B")
+        self.assertEqual(by_id["batch:TRANIDX"]["proof_grade"], "B")
+        self.assertEqual(by_id["batch:CLOSEFIL"]["proof_grade"], "B")
+        self.assertEqual(by_id["batch:OPENFIL"]["proof_grade"], "B")
+        self.assertGreater(by_id["online:CAVW"]["source_ref_count"], 0)
+
+    def test_parity_evidence_materializes_traces_edges_and_gaps(self) -> None:
+        evidence = build_parity_evidence(
+            SOURCE,
+            self.db_path,
+            source_head="59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e",
+        )
+        self.assertEqual(evidence["summary"]["capability_count"], 50)
+        self.assertTrue(evidence["summary"]["one_for_one_parity_ready"])
+        self.assertGreater(evidence["summary"]["static_oracle_or_better_count"], 0)
+        self.assertEqual(evidence["summary"]["gap_count"], 0)
+        self.assertGreaterEqual(len(evidence["golden_traces"]), 21)
+        self.assertTrue(any(row["trace_id"] == "signon_admin_success" for row in evidence["golden_traces"]))
+        self.assertTrue(any(row["trace_id"] == "regular_main_menu_options" for row in evidence["golden_traces"]))
+        user_trace = next(
+            row for row in evidence["golden_traces"] if row["trace_id"] == "user_maintenance_add_update_delete"
+        )
+        self.assertEqual(user_trace["proof_grade"], "B")
+        self.assertEqual(user_trace["expected"]["required_field_messages"]["user_type"], "User Type can NOT be empty...")
+        self.assertEqual(user_trace["expected"]["non_admin_signon_route"], "CM00")
+        self.assertTrue(any(row["trace_id"] == "transaction_add_ct02_validated_write" for row in evidence["golden_traces"]))
+        self.assertTrue(any(row["trace_id"] == "account_update_caup_validated_rewrite" for row in evidence["golden_traces"]))
+        self.assertTrue(any(row["trace_id"] == "card_detail_ccdl_account_1" for row in evidence["golden_traces"]))
+        self.assertTrue(any(row["trace_id"] == "card_update_ccup_validated_rewrite" for row in evidence["golden_traces"]))
+        mq_date_trace = next(row for row in evidence["golden_traces"] if row["trace_id"] == "mq_system_date_cdrd_reply")
+        self.assertEqual(mq_date_trace["expected"]["reply_message"], "SYSTEM DATE : 05-23-2026SYSTEM TIME : 11:12:13")
+        mq_account_trace = next(
+            row for row in evidence["golden_traces"] if row["trace_id"] == "mq_account_inquiry_cdra_success_and_invalid"
+        )
+        self.assertTrue(mq_account_trace["expected"]["reply_has_account_label"])
+        self.assertIn("INVALID REQUEST PARAMETERS", mq_account_trace["expected"]["not_found_reply"])
+        resource_trace = next(
+            row for row in evidence["golden_traces"] if row["trace_id"] == "batch_resource_setup_gdg_vsam_aix_cics"
+        )
+        self.assertEqual(resource_trace["expected"]["resource_count"], 6)
+        self.assertEqual(resource_trace["expected"]["tranidx_keys"], {"length": 26, "offset": 304})
+        self.assertTrue(resource_trace["expected"]["file_sets_match"])
+        ctli_trace = next(row for row in evidence["golden_traces"] if row["trace_id"] == "transaction_type_lookup")
+        self.assertEqual(ctli_trace["expected"]["legacy_transaction"], "CTLI")
+        self.assertEqual(ctli_trace["expected"]["page_size"], 7)
+        self.assertEqual(ctli_trace["expected"]["type_filter_result"], ["01"])
+        self.assertTrue(any(row["trace_id"] == "transaction_type_cttu_validated_upsert_delete" for row in evidence["golden_traces"]))
+        self.assertTrue(any(row["trace_id"] == "bill_payment_full_balance" for row in evidence["golden_traces"]))
+        self.assertTrue(any(row["trace_id"] == "posttran_reject_codes" for row in evidence["golden_traces"]))
+        self.assertTrue(any(row["trace_id"] == "pending_authorization_cpvs_summary_page" for row in evidence["golden_traces"]))
+        self.assertTrue(any(row["trace_id"] == "pending_authorization_cpvd_detail_lookup" for row in evidence["golden_traces"]))
+        self.assertTrue(any(row["trace_id"] == "pending_authorization_cp00_request_response_and_insert" for row in evidence["golden_traces"]))
+        self.assertTrue(any(row["trace_id"] == "pending_authorization_cpvd_fraud_and_cbpaup0j_purge" for row in evidence["golden_traces"]))
+        comb_trace = next(
+            row for row in evidence["golden_traces"] if row["trace_id"] == "combined_transactions_seed_plus_interest_preview"
+        )
+        self.assertEqual(comb_trace["proof_grade"], "B")
+        self.assertEqual(comb_trace["expected"]["sort"]["symbol"], "TRAN-ID")
+        self.assertTrue(comb_trace["expected"]["transaction_ids_sorted"])
+        mnt_trace = next(
+            row for row in evidence["golden_traces"] if row["trace_id"] == "batch_transaction_type_mnttrdb2_fixed_record_flow"
+        )
+        self.assertEqual(mnt_trace["proof_grade"], "B")
+        self.assertEqual(mnt_trace["expected"]["legacy_program"], "COBTUPDT")
+        self.assertEqual(mnt_trace["expected"]["return_code"], 4)
+        self.assertEqual(mnt_trace["expected"]["applied_count"], 3)
+        self.assertEqual(mnt_trace["expected"]["error_count"], 4)
+        tranbkp_trace = next(
+            row for row in evidence["golden_traces"] if row["trace_id"] == "transaction_master_tranbkp_backup_redefine"
+        )
+        self.assertEqual(tranbkp_trace["proof_grade"], "B")
+        self.assertEqual(tranbkp_trace["expected"]["define_cluster"]["keys"], {"length": 16, "offset": 0})
+        self.assertEqual(tranbkp_trace["expected"]["record_count"], 300)
+        tranextr_trace = next(
+            row for row in evidence["golden_traces"] if row["trace_id"] == "transaction_type_tranextr_reference_extract"
+        )
+        self.assertEqual(tranextr_trace["proof_grade"], "B")
+        self.assertEqual(tranextr_trace["expected"]["lrecl"], 60)
+        self.assertEqual(tranextr_trace["expected"]["type_record_lengths"], [60])
+        self.assertEqual(tranextr_trace["expected"]["category_record_lengths"], [60])
+        db2_trace = next(
+            row for row in evidence["golden_traces"] if row["trace_id"] == "db2_reference_creadb21_schema_and_load"
+        )
+        self.assertEqual(db2_trace["proof_grade"], "B")
+        self.assertEqual(db2_trace["expected"]["steps"], ["FREEPLN", "CRCRDDB", "RUNTEP2", "LDTCCAT"])
+        self.assertEqual(db2_trace["expected"]["transaction_type_load_count"], 7)
+        self.assertEqual(db2_trace["expected"]["transaction_category_load_count"], 18)
+        self.assertTrue(any(row["edge_case_id"] == "transaction_largest_credit_or_negative" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "signon_lowercase_credentials" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "user_security_required_fields" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "user_security_non_admin_type_regular_route" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "ct02_signed_amount_format" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "caup_no_change_update" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "ccdl_ccup_card_key_validation" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "ccup_card_update_validation" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "ctli_cursor_filters_and_page_size" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "cttu_child_delete_guard" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "mnttrdb2_fixed_record_actions_and_sql_errors" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "creastmt_fixed_width_source_sort" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "combtran_transaction_id_sort_repro" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "tranbkp_transaction_master_ksds_contract" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "tranextr_reference_extract_fixed_width" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "creadb21_db2_reference_schema_and_load_order" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "pending_authorization_ims_segment_header_offset" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "authorization_available_credit_boundary" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "authorization_purge_reverse_date_key" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "mq_cdrd_request_payload_ignored" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "mq_cdra_inqa_account_key_validation" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "batch_gdg_limit_scratch_first_generation" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "vsam_esds_rrds_user_security_layout" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "transaction_aix_processed_timestamp_key" for row in evidence["edge_cases"]))
+        self.assertTrue(any(row["edge_case_id"] == "cics_file_control_command_set" for row in evidence["edge_cases"]))
+        self.assertEqual(evidence["next_gap_ranking"], [])
+
+
+if __name__ == "__main__":
+    unittest.main()

modern_code/tests/test_service.py

@@ -0,0 +1,758 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+
+from carddemo.repository import connect, seed_from_legacy
+from carddemo.service import CardDemoService
+
+
+ROOT = Path(__file__).resolve().parents[2]
+SOURCE = ROOT / "source"
+
+
+class ServiceTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.tmp = tempfile.TemporaryDirectory()
+        self.db_path = Path(self.tmp.name) / "carddemo.sqlite"
+        self.counts = seed_from_legacy(SOURCE, self.db_path, reset=True)
+        self.service = CardDemoService(self.db_path)
+
+    def tearDown(self) -> None:
+        self.tmp.cleanup()
+
+    def test_seed_counts(self) -> None:
+        self.assertEqual(self.counts["customers"], 50)
+        self.assertEqual(self.counts["accounts"], 50)
+        self.assertEqual(self.counts["cards"], 50)
+        self.assertEqual(self.counts["transactions"], 300)
+        self.assertGreater(self.counts["disclosure_groups"], 0)
+        self.assertGreater(self.counts["transaction_category_balances"], 0)
+        self.assertEqual(self.counts["users"], 10)
+        self.assertEqual(self.counts["pending_authorization_summaries"], 21)
+        self.assertEqual(self.counts["pending_authorization_details"], 202)
+
+    def test_signon_routes_admin_and_rejects_bad_password(self) -> None:
+        success = self.service.signon("admin001", "password")
+        self.assertTrue(success["authenticated"])
+        self.assertEqual(success["legacy_transaction"], "CC00")
+        self.assertEqual(success["route_transaction"], "CA00")
+        self.assertEqual(success["route_program"], "COADM01C")
+        self.assertEqual(success["menu"]["option_count"], 6)
+
+        failure = self.service.signon("ADMIN001", "wrong")
+        self.assertFalse(failure["authenticated"])
+        self.assertEqual(failure["reason"], "wrong_password")
+        self.assertIn("Wrong Password", failure["message"])
+
+    def test_main_and_admin_menus_match_copybook_counts(self) -> None:
+        main = self.service.main_menu()
+        admin = self.service.admin_menu()
+        self.assertEqual(main["legacy_transaction"], "CM00")
+        self.assertEqual(main["option_count"], 11)
+        self.assertEqual(main["options"][9]["program"], "COBIL00C")
+        self.assertEqual(admin["legacy_transaction"], "CA00")
+        self.assertEqual(admin["option_count"], 6)
+        self.assertEqual(admin["options"][1]["program"], "COUSR01C")
+        with self.assertRaises(ValueError):
+            self.service.select_menu_option("CM00", 99)
+
+    def test_user_maintenance_add_update_delete(self) -> None:
+        payload = {
+            "user_id": "qauser01",
+            "first_name": "Quality",
+            "last_name": "Check",
+            "password": "secret",
+            "user_type": "U",
+        }
+        required_messages = {
+            "user_id": "User ID can NOT be empty...",
+            "first_name": "First Name can NOT be empty...",
+            "last_name": "Last Name can NOT be empty...",
+            "password": "Password can NOT be empty...",
+            "user_type": "User Type can NOT be empty...",
+        }
+        for field, message in required_messages.items():
+            invalid = dict(payload)
+            invalid[field] = ""
+            with self.assertRaises(ValueError) as err:
+                self.service.add_user(invalid)
+            self.assertEqual(str(err.exception), message)
+
+        added = self.service.add_user(payload)
+        self.assertEqual(added["legacy_transaction"], "CU01")
+        self.assertEqual(added["user"]["user_id"], "QAUSER01")
+        self.assertEqual(self.service.get_user("qauser01")["password"], "SECRET")
+        with self.assertRaises(ValueError) as err:
+            self.service.add_user(payload)
+        self.assertEqual(str(err.exception), "User ID already exist...")
+
+        non_admin = self.service.add_user(
+            {
+                "user_id": "qauser02",
+                "first_name": "Quality",
+                "last_name": "Nonadmin",
+                "password": "secret",
+                "user_type": "z",
+            }
+        )
+        self.assertEqual(non_admin["user"]["user_type"], "Z")
+        self.assertEqual(self.service.signon("qauser02", "secret")["route_transaction"], "CM00")
+
+        updated = self.service.update_user(
+            "qauser01",
+            {
+                "first_name": "Quality",
+                "last_name": "Updated",
+                "password": "secret2",
+                "user_type": "A",
+            },
+        )
+        self.assertEqual(updated["legacy_transaction"], "CU02")
+        self.assertEqual(updated["user"]["last_name"], "Updated")
+        self.assertEqual(updated["user"]["password"], "SECRET2")
+        with self.assertRaises(ValueError) as err:
+            self.service.update_user("qauser01", updated["user"])
+        self.assertEqual(str(err.exception), "Please modify to update ...")
+        with self.assertRaises(ValueError) as err:
+            self.service.update_user("", updated["user"])
+        self.assertEqual(str(err.exception), "User ID can NOT be empty...")
+
+        deleted = self.service.delete_user("qauser01")
+        self.assertEqual(deleted["legacy_transaction"], "CU03")
+        self.assertIsNone(self.service.get_user("qauser01"))
+        self.service.delete_user("qauser02")
+        with self.assertRaises(KeyError) as err:
+            self.service.delete_user("qauser01")
+        self.assertEqual(err.exception.args[0], "User ID NOT found...")
+
+    def test_account_bundle_joins_customer_card_transaction(self) -> None:
+        bundle = self.service.get_account_bundle(1)
+        self.assertIsNotNone(bundle)
+        assert bundle is not None
+        self.assertEqual(bundle["account"]["account_id"], 1)
+        self.assertGreaterEqual(len(bundle["cards"]), 1)
+        self.assertGreaterEqual(len(bundle["customers"]), 1)
+
+    def test_card_detail_follows_ccdl_lookup_shape(self) -> None:
+        bundle = self.service.get_account_bundle(1)
+        assert bundle is not None
+        card = bundle["cards"][0]
+        detail = self.service.get_card_detail(card["card_number"], account_id=1)
+        self.assertEqual(detail["legacy_transaction"], "CCDL")
+        self.assertEqual(detail["legacy_program"], "COCRDSLC")
+        self.assertEqual(detail["card"]["card_number"], card["card_number"])
+        self.assertEqual(detail["card"]["account_id"], 1)
+        self.assertIn("embossed_name", detail["editable_fields"])
+        with self.assertRaisesRegex(ValueError, "16 digit number"):
+            self.service.get_card_detail("123", account_id=1)
+        with self.assertRaisesRegex(KeyError, "Did not find cards"):
+            self.service.get_card_detail(card["card_number"], account_id=999)
+
+    def test_card_update_follows_ccup_validation_and_rewrite_shape(self) -> None:
+        bundle = self.service.get_account_bundle(1)
+        assert bundle is not None
+        card = bundle["cards"][0]
+        old_year, old_month, old_day = card["expiration_date"].split("-")
+        updated = self.service.update_card(
+            card["card_number"],
+            {
+                "account_id": 1,
+                "embossed_name": "Trace Holder",
+                "active_status": "N",
+                "expiration_month": "12",
+                "expiration_year": "2030",
+            },
+        )
+        self.assertEqual(updated["legacy_transaction"], "CCUP")
+        self.assertEqual(updated["legacy_program"], "COCRDUPC")
+        self.assertEqual(updated["card"]["embossed_name"], "Trace Holder")
+        self.assertEqual(updated["card"]["active_status"], "N")
+        self.assertEqual(updated["card"]["expiration_date"], f"2030-12-{old_day}")
+        self.assertIn("expiration_day", updated["preserved_fields"])
+        self.assertIn("expiration_date", updated["changed_fields"])
+        self.assertEqual(updated["card"]["cvv"], card["cvv"])
+        with self.assertRaisesRegex(ValueError, "No change detected"):
+            self.service.update_card(
+                card["card_number"],
+                {
+                    "account_id": 1,
+                    "embossed_name": "trace holder",
+                    "active_status": "N",
+                    "expiration_month": "12",
+                    "expiration_year": "2030",
+                },
+            )
+        self.assertNotEqual((old_year, old_month), ("2030", "12"))
+
+    def test_card_update_rejects_ccup_screen_edge_cases(self) -> None:
+        card = self.service.get_account_bundle(1)["cards"][0]
+        with self.assertRaisesRegex(ValueError, "Card name can only contain alphabets"):
+            self.service.update_card(card["card_number"], {"embossed_name": "Bad123"})
+        with self.assertRaisesRegex(ValueError, "Card Active Status must be Y or N"):
+            self.service.update_card(card["card_number"], {"active_status": "X"})
+        with self.assertRaisesRegex(ValueError, "Card expiry month must be between 1 and 12"):
+            self.service.update_card(card["card_number"], {"expiration_month": "13"})
+        with self.assertRaisesRegex(ValueError, "Invalid card expiry year"):
+            self.service.update_card(card["card_number"], {"expiration_year": "2100"})
+
+    def test_account_update_follows_caup_validation_and_rewrite_shape(self) -> None:
+        before = self.service.get_account_bundle(1)
+        assert before is not None
+        account = before["account"]
+        updated = self.service.update_account(
+            1,
+            {
+                "active_status": "N",
+                "credit_limit_cents": account["credit_limit_cents"] + 10000,
+                "cash_credit_limit_cents": account["cash_credit_limit_cents"] + 5000,
+                "group_id": "TRACEGRP",
+                "customer": {"zip_code": "27514"},
+            },
+        )
+        self.assertEqual(updated["legacy_transaction"], "CAUP")
+        self.assertEqual(updated["legacy_program"], "COACTUPC")
+        self.assertEqual(updated["active_status"], "N")
+        self.assertEqual(updated["credit_limit_cents"], account["credit_limit_cents"] + 10000)
+        self.assertEqual(updated["cash_credit_limit_cents"], account["cash_credit_limit_cents"] + 5000)
+        self.assertEqual(updated["group_id"], "TRACEGRP")
+        self.assertEqual(updated["customer"]["zip_code"], "27514")
+        self.assertIn("credit_limit_cents", updated["updated_account_fields"])
+        self.assertIn("zip_code", updated["updated_customer_fields"])
+
+        with self.assertRaisesRegex(ValueError, "No changes"):
+            self.service.update_account(
+                1,
+                {
+                    "active_status": "N",
+                    "credit_limit_cents": updated["credit_limit_cents"],
+                    "cash_credit_limit_cents": updated["cash_credit_limit_cents"],
+                    "group_id": "TRACEGRP",
+                    "customer": {"zip_code": "27514"},
+                },
+            )
+
+    def test_account_update_rejects_caup_screen_edge_cases(self) -> None:
+        with self.assertRaisesRegex(ValueError, "Account Status must be Y or N"):
+            self.service.update_account(1, {"active_status": "X"})
+        with self.assertRaisesRegex(ValueError, "Credit Limit is not valid"):
+            self.service.update_account(1, {"credit_limit_cents": "not-money"})
+        with self.assertRaisesRegex(ValueError, "State: is not a valid state code"):
+            self.service.update_account(1, {"customer": {"state": "ZZ"}})
+        with self.assertRaisesRegex(KeyError, "Account ID NOT found"):
+            self.service.update_account(999999, {"active_status": "N"})
+
+    def test_bill_payment_adds_credit_transaction(self) -> None:
+        before = self.service.get_account_bundle(1)
+        assert before is not None
+        before_balance = before["account"]["current_balance_cents"]
+        transaction = self.service.bill_payment(1, before_balance)
+        after = self.service.get_account_bundle(1)
+        assert after is not None
+        self.assertEqual(transaction["type_code"], "02")
+        self.assertEqual(transaction["category_code"], "0002")
+        self.assertEqual(transaction["source"], "POS TERM")
+        self.assertEqual(transaction["amount_cents"], before_balance)
+        self.assertEqual(after["account"]["current_balance_cents"], 0)
+
+    def test_bill_payment_rejects_partial_payment_for_legacy_full_pay_flow(self) -> None:
+        with self.assertRaises(ValueError):
+            self.service.bill_payment(1, 2500)
+
+    def test_post_transaction_accepts_and_updates_account_and_category_balance(self) -> None:
+        before = self.service.get_account_bundle(1)
+        assert before is not None
+        account = before["account"]
+        card_number = before["cards"][0]["card_number"]
+        conn = connect(self.db_path)
+        try:
+            starting_tcatbal = conn.execute(
+                """
+                SELECT balance_cents FROM transaction_category_balances
+                WHERE account_id = ? AND type_code = ? AND category_code = ?
+                """,
+                (1, "01", "0001"),
+            ).fetchone()
+            starting_tcatbal_cents = int(starting_tcatbal["balance_cents"]) if starting_tcatbal else 0
+        finally:
+            conn.close()
+        result = self.service.post_transaction(
+            {
+                "card_number": card_number,
+                "amount_cents": 100,
+                "type_code": "01",
+                "category_code": "0001",
+                "source": "TEST",
+                "description": "POSTTRAN ACCEPT TEST",
+                "merchant_id": "123456789",
+                "merchant_name": "POSTTRAN TEST",
+                "merchant_city": "BATCH",
+                "merchant_zip": "00000",
+                "original_timestamp": f"{account['expiration_date']} 00:00:00.000000",
+                "processed_timestamp": f"{account['expiration_date']} 00:00:00.000000",
+            }
+        )
+        self.assertTrue(result["accepted"])
+        after = self.service.get_account_bundle(1)
+        assert after is not None
+        self.assertEqual(after["account"]["current_balance_cents"], account["current_balance_cents"] + 100)
+        self.assertEqual(after["account"]["current_cycle_credit_cents"], account["current_cycle_credit_cents"] + 100)
+        conn = connect(self.db_path)
+        try:
+            ending_tcatbal = conn.execute(
+                """
+                SELECT balance_cents FROM transaction_category_balances
+                WHERE account_id = ? AND type_code = ? AND category_code = ?
+                """,
+                (1, "01", "0001"),
+            ).fetchone()
+        finally:
+            conn.close()
+        assert ending_tcatbal is not None
+        self.assertEqual(int(ending_tcatbal["balance_cents"]), starting_tcatbal_cents + 100)
+
+    def test_post_transaction_rejects_invalid_overlimit_and_expired_cases(self) -> None:
+        before = self.service.get_account_bundle(1)
+        assert before is not None
+        account = before["account"]
+        card_number = before["cards"][0]["card_number"]
+        invalid = self.service.post_transaction(
+            {"card_number": "9999999999999999", "amount_cents": 100},
+            reject_on_failure=False,
+        )
+        self.assertFalse(invalid["accepted"])
+        self.assertEqual(invalid["validation"]["reason_code"], 100)
+        overlimit = self.service.post_transaction(
+            {
+                "card_number": card_number,
+                "amount_cents": account["credit_limit_cents"] + 1,
+                "original_timestamp": f"{account['expiration_date']} 00:00:00.000000",
+            },
+            reject_on_failure=False,
+        )
+        self.assertFalse(overlimit["accepted"])
+        self.assertEqual(overlimit["validation"]["reason_code"], 102)
+        expired = self.service.post_transaction(
+            {
+                "card_number": card_number,
+                "amount_cents": 1,
+                "original_timestamp": "2099-01-01 00:00:00.000000",
+            },
+            reject_on_failure=False,
+        )
+        self.assertFalse(expired["accepted"])
+        self.assertEqual(expired["validation"]["reason_code"], 103)
+
+    def test_transaction_add_follows_ct02_validation_and_transact_write(self) -> None:
+        before = self.service.get_account_bundle(1)
+        assert before is not None
+        before_balance = before["account"]["current_balance_cents"]
+        transaction = self.service.add_transaction(
+            {
+                "account_id": 1,
+                "type_code": "01",
+                "category_code": "0001",
+                "source": "POS TERM",
+                "description": "CT02 SOURCE VALIDATION",
+                "amount_cents": -1234,
+                "original_timestamp": "2022-01-30",
+                "processed_timestamp": "2022-01-31",
+                "merchant_id": "123456789",
+                "merchant_name": "CT02 MERCHANT",
+                "merchant_city": "SEATTLE",
+                "merchant_zip": "98101",
+                "confirm": "Y",
+            }
+        )
+        after = self.service.get_account_bundle(1)
+        assert after is not None
+        self.assertEqual(transaction["legacy_transaction"], "CT02")
+        self.assertEqual(transaction["legacy_program"], "COTRN02C")
+        self.assertEqual(transaction["account_id"], 1)
+        self.assertEqual(transaction["legacy_amount"], "-00000012.34")
+        self.assertEqual(transaction["original_timestamp"], "2022-01-30")
+        self.assertEqual(after["account"]["current_balance_cents"], before_balance)
+        self.assertTrue(any(row["transaction_id"] == transaction["transaction_id"] for row in after["transactions"]))
+
+    def test_transaction_add_rejects_ct02_screen_edge_cases(self) -> None:
+        base = {
+            "card_number": self.service.get_account_bundle(1)["cards"][0]["card_number"],
+            "type_code": "01",
+            "category_code": "0001",
+            "source": "POS TERM",
+            "description": "CT02 REJECT TEST",
+            "amount": "+00000012.34",
+            "original_timestamp": "2022-01-30",
+            "processed_timestamp": "2022-01-31",
+            "merchant_id": "123456789",
+            "merchant_name": "CT02 MERCHANT",
+            "merchant_city": "SEATTLE",
+            "merchant_zip": "98101",
+        }
+        with self.assertRaisesRegex(ValueError, "Confirm to add"):
+            self.service.add_transaction(base)
+        with self.assertRaisesRegex(ValueError, "Amount should be"):
+            self.service.add_transaction({**base, "amount": "12.34", "confirm": "Y"})
+        with self.assertRaisesRegex(ValueError, "Proc Date - Not a valid date"):
+            self.service.add_transaction({**base, "processed_timestamp": "2022-02-31", "confirm": "Y"})
+        with self.assertRaisesRegex(ValueError, "Merchant ID must be Numeric"):
+            self.service.add_transaction({**base, "merchant_id": "ABC", "confirm": "Y"})
+
+    def test_transaction_type_list_follows_ctli_cursor_filters(self) -> None:
+        first_page = self.service.transaction_types(page_size=3)
+        self.assertEqual(first_page["legacy_transaction"], "CTLI")
+        self.assertEqual(first_page["legacy_program"], "COTRTLIC")
+        self.assertEqual(first_page["page"]["page_size"], 3)
+        self.assertEqual([row["type_code"] for row in first_page["types"]], ["01", "02", "03"])
+        self.assertEqual(first_page["page"]["next_start_key"], "04")
+
+        next_page = self.service.transaction_types(start_key=first_page["page"]["next_start_key"], page_size=3)
+        self.assertEqual([row["type_code"] for row in next_page["types"]], ["04", "05", "06"])
+
+        previous_page = self.service.transaction_types(start_key="07", direction="backward", page_size=3)
+        self.assertEqual([row["type_code"] for row in previous_page["types"]], ["04", "05", "06"])
+
+        type_filtered = self.service.transaction_types(type_filter="1")
+        self.assertEqual([row["type_code"] for row in type_filtered["types"]], ["01"])
+
+        description_filtered = self.service.transaction_types(description_filter="%PAYMENT%")
+        self.assertGreaterEqual(len(description_filtered["types"]), 1)
+        self.assertTrue(all("PAYMENT" in row["description"].upper() for row in description_filtered["types"]))
+
+    def test_transaction_type_maintenance_follows_cttu_validation_and_write_shape(self) -> None:
+        inserted = self.service.upsert_transaction_type({"type_code": "8", "description": "Manual Review"})
+        self.assertEqual(inserted["legacy_transaction"], "CTTU")
+        self.assertEqual(inserted["legacy_program"], "COTRTUPC")
+        self.assertEqual(inserted["type_code"], "08")
+        self.assertEqual(inserted["action"], "inserted")
+
+        updated = self.service.upsert_transaction_type({"type_code": "08", "description": "Manual Review 2"})
+        self.assertEqual(updated["action"], "updated")
+        self.assertEqual(updated["description"], "Manual Review 2")
+        with self.assertRaisesRegex(ValueError, "No change detected"):
+            self.service.upsert_transaction_type({"type_code": "08", "description": "manual review 2"})
+
+        deleted = self.service.delete_transaction_type("08")
+        self.assertTrue(deleted["deleted"])
+        with self.assertRaisesRegex(KeyError, "No record found"):
+            self.service.delete_transaction_type("08")
+
+    def test_transaction_type_maintenance_rejects_cttu_screen_edge_cases(self) -> None:
+        with self.assertRaisesRegex(ValueError, "Tran Type code must be supplied"):
+            self.service.upsert_transaction_type({"type_code": "", "description": "Valid Desc"})
+        with self.assertRaisesRegex(ValueError, "Tran Type code must be numeric"):
+            self.service.upsert_transaction_type({"type_code": "A1", "description": "Valid Desc"})
+        with self.assertRaisesRegex(ValueError, "Tran Type code must not be zero"):
+            self.service.upsert_transaction_type({"type_code": "00", "description": "Valid Desc"})
+        with self.assertRaisesRegex(ValueError, "Transaction Desc must be supplied"):
+            self.service.upsert_transaction_type({"type_code": "08", "description": ""})
+        with self.assertRaisesRegex(ValueError, "Transaction Desc can have numbers or alphabets only"):
+            self.service.upsert_transaction_type({"type_code": "08", "description": "Bad-Desc"})
+        with self.assertRaisesRegex(ValueError, "Please delete associated child records first"):
+            self.service.delete_transaction_type("01")
+
+    def test_batch_transaction_type_maintenance_follows_mnttrdb2_fixed_record_flow(self) -> None:
+        result = self.service.maintain_transaction_types(
+            [
+                "*COMMENT".ljust(53),
+                "A09" + "Batch Review".ljust(50),
+                "U09" + "Batch Review 2".ljust(50),
+                "D09" + "".ljust(50),
+            ]
+        )
+
+        self.assertEqual(result["legacy_job"], "MNTTRDB2")
+        self.assertEqual(result["legacy_program"], "COBTUPDT")
+        self.assertEqual(result["legacy_driver"], "IKJEFT01")
+        self.assertEqual(result["input_dd"], "INPFILE")
+        self.assertEqual(result["return_code"], 0)
+        self.assertEqual(result["counts"]["input_record_count"], 4)
+        self.assertEqual(result["counts"]["comment_count"], 1)
+        self.assertEqual(result["counts"]["applied_count"], 3)
+        self.assertEqual([row["status"] for row in result["actions"]], ["comment_ignored", "inserted", "updated", "deleted"])
+        conn = connect(self.db_path)
+        try:
+            self.assertIsNone(
+                conn.execute("SELECT type_code FROM transaction_types WHERE type_code = '09'").fetchone()
+            )
+        finally:
+            conn.close()
+
+    def test_batch_transaction_type_maintenance_reports_cobol_return_code_for_errors(self) -> None:
+        result = self.service.maintain_transaction_types(
+            [
+                "X09" + "Bad Action".ljust(50),
+                "U98" + "Missing Update".ljust(50),
+                "D98" + "".ljust(50),
+                "A01" + "Duplicate Purchase".ljust(50),
+                "D01" + "".ljust(50),
+            ]
+        )
+
+        self.assertEqual(result["return_code"], 4)
+        self.assertEqual(result["counts"]["applied_count"], 0)
+        self.assertEqual(result["counts"]["error_count"], 5)
+        messages = [row["message"] for row in result["actions"]]
+        self.assertIn("ERROR: TYPE NOT VALID", messages)
+        self.assertIn("No records found.", messages)
+        self.assertIn("Error accessing: TRANSACTION_TYPE table. SQLCODE:-803", messages)
+        self.assertIn("Error accessing: TRANSACTION_TYPE table. SQLCODE:-532", messages)
+
+    def test_transaction_report_groups_seed_data_by_account(self) -> None:
+        report = self.service.transaction_report(account_id=1, limit=1000)
+        self.assertEqual(report["legacy_job"], "TRANREPT")
+        self.assertGreater(report["totals"]["transaction_count"], 0)
+        self.assertTrue(all(row["account_id"] == 1 for row in report["rows"]))
+        self.assertEqual(
+            report["totals"]["total_amount_cents"],
+            sum(row["amount_cents"] for row in report["rows"]),
+        )
+
+    def test_account_statement_materializes_legacy_sections(self) -> None:
+        statement = self.service.account_statement(1)
+        self.assertEqual(statement["legacy_job"], "CREASTMT")
+        self.assertEqual(statement["legacy_programs"], ["CBSTM03A", "CBSTM03B"])
+        self.assertEqual(statement["source_sort_key"], "card_number,transaction_id")
+        self.assertIn("START OF STATEMENT", statement["plain_text_lines"][0])
+        self.assertIn("END OF STATEMENT", statement["plain_text_lines"][-1])
+        self.assertTrue(all(len(line) == statement["statement_lines_lrecl"] for line in statement["plain_text_lines"]))
+        self.assertTrue(all(len(line) <= statement["html_lines_lrecl"] for line in statement["html_lines"]))
+        self.assertGreater(statement["transaction_count"], 0)
+        self.assertEqual(statement["transaction_count"], len(statement["statement_rows"]))
+        self.assertEqual(
+            statement["total_expense_cents"],
+            sum(row["amount_cents"] for row in statement["statement_rows"]),
+        )
+        sort_keys = [(row["card_number"], row["transaction_id"]) for row in statement["statement_rows"]]
+        self.assertEqual(sort_keys, sorted(sort_keys))
+
+    def test_interest_projection_uses_disclosure_rates_and_formula(self) -> None:
+        projection = self.service.interest_projection(limit=20)
+        self.assertEqual(projection["legacy_job"], "INTCALC")
+        self.assertGreater(len(projection["rows"]), 0)
+        first = projection["rows"][0]
+        expected = int(
+            (first["balance_cents"] * first["interest_rate_basis_points"]) / 120000
+        )
+        self.assertEqual(first["monthly_interest_cents"], expected)
+        self.assertEqual(projection["generated_transactions"][0]["type_code"], "01")
+        self.assertEqual(projection["generated_transactions"][0]["category_code"], "0005")
+
+    def test_transaction_master_backup_models_tranbkp_repro_and_ksds_redefine(self) -> None:
+        backup = self.service.transaction_master_backup(limit=5)
+        self.assertEqual(backup["legacy_job"], "TRANBKP")
+        self.assertEqual(backup["legacy_proc"], "REPROC")
+        self.assertEqual(backup["source_dataset"], "AWS.M2.CARDDEMO.TRANSACT.VSAM.KSDS")
+        self.assertEqual(backup["backup_dataset"], "AWS.M2.CARDDEMO.TRANSACT.BKUP(+1)")
+        self.assertEqual(backup["define_cluster"]["keys"], {"length": 16, "offset": 0})
+        self.assertEqual(backup["define_cluster"]["record_size"], {"min": 350, "max": 350})
+        self.assertEqual(backup["record_count"], 300)
+        self.assertEqual(len(backup["preview_records"]), 5)
+        self.assertTrue(all(row["record_length"] == 350 for row in backup["preview_records"]))
+        keys = [row["key"] for row in backup["preview_records"]]
+        self.assertEqual(keys, sorted(keys))
+
+    def test_transaction_type_extract_models_tranextr_dsntiaul_records(self) -> None:
+        extract = self.service.transaction_type_extract()
+        self.assertEqual(extract["legacy_job"], "TRANEXTR")
+        self.assertEqual(extract["legacy_program"], "DSNTIAUL")
+        self.assertEqual(extract["legacy_plan"], "DSNTIAUL")
+        self.assertEqual(extract["lrecl"], 60)
+        self.assertEqual(extract["counts"]["transaction_types"], 7)
+        self.assertEqual(extract["counts"]["transaction_categories"], 18)
+        type_records = extract["records"]["transaction_types"]
+        category_records = extract["records"]["transaction_categories"]
+        self.assertTrue(all(len(record) == 60 for record in type_records + category_records))
+        self.assertEqual(type_records[0][:2], "01")
+        self.assertTrue(type_records[0].endswith("0" * 8))
+        self.assertEqual(category_records[0][:6], "010001")
+        self.assertTrue(category_records[0].endswith("0" * 4))
+
+    def test_db2_reference_setup_models_creadb21_schema_and_loads(self) -> None:
+        setup = self.service.db2_reference_setup()
+        self.assertEqual(setup["legacy_job"], "CREADB21")
+        self.assertEqual(setup["legacy_jcl_job"], "CREADB2")
+        self.assertEqual(setup["db2_system"], "DAZ1")
+        self.assertEqual(setup["database"]["name"], "CARDDEMO")
+        self.assertEqual([step["step"] for step in setup["steps"]], ["FREEPLN", "CRCRDDB", "RUNTEP2", "LDTCCAT"])
+        self.assertEqual(setup["tables"]["transaction_type"]["load_count"], 7)
+        self.assertEqual(setup["tables"]["transaction_type_category"]["load_count"], 18)
+        self.assertEqual(
+            setup["tables"]["transaction_type_category"]["foreign_key"]["references"],
+            "CARDDEMO.TRANSACTION_TYPE(TR_TYPE)",
+        )
+        self.assertEqual(setup["tables"]["transaction_type_category"]["foreign_key"]["on_delete"], "RESTRICT")
+
+    def test_mq_system_date_cdrd_formats_source_reply(self) -> None:
+        result = self.service.mq_system_date({"request_message": "ANYTHING"}, now="2026-05-23T11:12:13")
+        self.assertEqual(result["legacy_transaction"], "CDRD")
+        self.assertEqual(result["legacy_program"], "CODATE01")
+        self.assertEqual(result["reply_queue"], "CARD.DEMO.REPLY.DATE")
+        self.assertEqual(result["system_date"], "05-23-2026")
+        self.assertEqual(result["system_time"], "11:12:13")
+        self.assertEqual(result["reply_message"], "SYSTEM DATE : 05-23-2026SYSTEM TIME : 11:12:13")
+
+    def test_mq_account_inquiry_cdra_reads_account_and_rejects_invalid_requests(self) -> None:
+        result = self.service.mq_account_inquiry({"function": "INQA", "account_id": 1})
+        self.assertEqual(result["legacy_transaction"], "CDRA")
+        self.assertEqual(result["legacy_program"], "COACCT01")
+        self.assertTrue(result["valid_request"])
+        self.assertEqual(result["request"]["account_id_text"], "00000000001")
+        self.assertEqual(result["account_data"]["account_id"], 1)
+        self.assertIn("ACCOUNT ID : 00000000001", result["reply_message"])
+        self.assertIn("ACCOUNT STATUS : Y", result["reply_message"])
+        self.assertIn("GROUP ID : ", result["reply_message"])
+
+        from_raw = self.service.mq_account_inquiry({"request_message": "INQA00000000001"})
+        self.assertTrue(from_raw["valid_request"])
+        self.assertEqual(from_raw["account_data"]["account_id"], 1)
+
+        not_found = self.service.mq_account_inquiry({"function": "INQA", "account_id": 99999999999})
+        self.assertFalse(not_found["valid_request"])
+        self.assertIn("INVALID REQUEST PARAMETERS ACCT ID : 99999999999", not_found["reply_message"])
+
+        bad_function = self.service.mq_account_inquiry({"function": "BAD", "account_id": 1})
+        self.assertFalse(bad_function["valid_request"])
+        self.assertIn("FUNCTION : BAD ", bad_function["reply_message"])
+
+    def test_batch_resource_setup_models_remaining_gdg_vsam_aix_and_cics_jobs(self) -> None:
+        setup = self.service.batch_resource_setup()
+        self.assertEqual(setup["legacy_jobs"], ["DEFGDGB", "DEFGDGD", "ESDSRRDS", "TRANIDX", "CLOSEFIL", "OPENFIL"])
+        self.assertEqual(setup["resource_count"], 6)
+
+        gdg_base = self.service.batch_resource_setup("DEFGDGB")
+        self.assertEqual(len(gdg_base["gdg_bases"]), 6)
+        self.assertEqual(gdg_base["gdg_bases"][0]["name"], "AWS.M2.CARDDEMO.TRANSACT.BKUP")
+        self.assertEqual(gdg_base["gdg_bases"][0]["limit"], 5)
+        self.assertTrue(gdg_base["gdg_bases"][0]["scratch"])
+
+        db2_gdg = self.service.batch_resource_setup("DEFGDGD")
+        self.assertEqual(db2_gdg["steps"][1]["target"], "AWS.M2.CARDDEMO.TRANTYPE.BKUP(+1)")
+        self.assertEqual(db2_gdg["steps"][1]["lrecl"], 60)
+        self.assertEqual(db2_gdg["steps"][1]["record_count"], 7)
+        self.assertEqual(db2_gdg["steps"][5]["record_count"], 51)
+
+        esds_rrds = self.service.batch_resource_setup("ESDSRRDS")
+        self.assertEqual(esds_rrds["instream_user_records"], 10)
+        self.assertEqual([cluster["organization"] for cluster in esds_rrds["clusters"]], ["NONINDEXED", "NUMBERED"])
+        self.assertEqual(esds_rrds["clusters"][0]["record_size"], [80, 80])
+
+        tranidx = self.service.batch_resource_setup("TRANIDX")
+        self.assertEqual(tranidx["alternate_index"]["keys"], {"length": 26, "offset": 304})
+        self.assertEqual(tranidx["path"]["pathentry"], "AWS.M2.CARDDEMO.TRANSACT.VSAM.AIX")
+        self.assertEqual(tranidx["bldindex"]["source_record_count"], 300)
+
+        closefil = self.service.batch_resource_setup("CLOSEFIL")
+        openfil = self.service.batch_resource_setup("OPENFIL")
+        self.assertEqual(closefil["cemt_code"], "CLO")
+        self.assertEqual(openfil["cemt_code"], "OPE")
+        self.assertEqual(closefil["files"], ["TRANSACT", "CCXREF", "ACCTDAT", "CXACAIX", "USRSEC"])
+        self.assertEqual(openfil["files"], closefil["files"])
+
+    def test_pending_authorization_summary_and_detail_use_ims_seed(self) -> None:
+        summary = self.service.pending_authorization_summary(1, page_size=5)
+        self.assertEqual(summary["legacy_transaction"], "CPVS")
+        self.assertEqual(summary["summary"]["approved_auth_count"], 6)
+        self.assertEqual(summary["summary"]["approved_auth_amount_cents"], 944)
+        self.assertEqual(len(summary["authorizations"]), 5)
+        self.assertTrue(summary["next_page"])
+
+        first = summary["authorizations"][0]
+        detail = self.service.pending_authorization_detail(1, authorization_key=first["authorization_key"])
+        self.assertEqual(detail["legacy_transaction"], "CPVD")
+        self.assertEqual(detail["authorization"]["transaction_id"], "960b9b5480d045a")
+        self.assertEqual(detail["authorization"]["authorization_date"], "10/27/23")
+        self.assertEqual(detail["authorization"]["authorization_response"], "A")
+
+    def test_authorization_request_updates_summary_and_inserts_detail(self) -> None:
+        before = self.service.pending_authorization_summary(1, page_size=1)
+        result = self.service.process_authorization_request(
+            {
+                "card_number": "9680294154603697",
+                "auth_date": "260523",
+                "auth_time": "111213",
+                "card_expiry_date": "1129",
+                "transaction_amount_cents": 100,
+                "merchant_category_code": "5442",
+                "merchant_id": "123501000675423",
+                "merchant_name": "Amazon.com",
+                "merchant_city": "Wilmington",
+                "merchant_state": "DE",
+                "merchant_zip": "19801",
+                "transaction_id": "AUTHREQ00000001",
+                "processing_datetime": "2026-05-23T11:12:13.456",
+            }
+        )
+        self.assertEqual(result["legacy_transaction"], "CP00")
+        self.assertTrue(result["approved"])
+        self.assertEqual(result["response"]["auth_resp_code"], "00")
+        self.assertTrue(result["written_to_pending_authorizations"])
+
+        after = self.service.pending_authorization_summary(1, page_size=1)
+        self.assertEqual(after["summary"]["approved_auth_count"], before["summary"]["approved_auth_count"] + 1)
+        detail = self.service.pending_authorization_detail(1, transaction_id="AUTHREQ00000001")
+        self.assertEqual(detail["authorization"]["approved_amount_cents"], 100)
+        self.assertEqual(detail["authorization"]["auth_id_code"], "111213")
+
+    def test_authorization_declines_invalid_card_without_write(self) -> None:
+        result = self.service.process_authorization_request(
+            {
+                "card_number": "9999999999999999",
+                "transaction_amount_cents": 100,
+                "transaction_id": "AUTHREQBAD0001",
+            }
+        )
+        self.assertFalse(result["approved"])
+        self.assertEqual(result["response"]["auth_resp_code"], "05")
+        self.assertEqual(result["response"]["auth_resp_reason"], "3100")
+        self.assertFalse(result["written_to_pending_authorizations"])
+
+    def test_authorization_fraud_mark_writes_authfrds_shadow_table(self) -> None:
+        summary = self.service.pending_authorization_summary(1, page_size=1)
+        auth_key = summary["authorizations"][0]["authorization_key"]
+        result = self.service.mark_authorization_fraud(1, auth_key, action="report", report_date="20260523")
+        self.assertEqual(result["legacy_program"], "COPAUS1C/COPAUS2C")
+        self.assertEqual(result["fraud_status"], "F")
+        detail = self.service.pending_authorization_detail(1, authorization_key=auth_key)
+        self.assertEqual(detail["authorization"]["auth_fraud"], "F")
+        conn = connect(self.db_path)
+        try:
+            count = conn.execute("SELECT COUNT(*) FROM authorization_frauds").fetchone()[0]
+        finally:
+            conn.close()
+        self.assertEqual(count, 1)
+
+    def test_purge_expired_authorizations_dry_run_and_apply(self) -> None:
+        dry_run = self.service.purge_expired_authorizations(current_yyddd=23305, expiry_days=5, dry_run=True)
+        self.assertEqual(dry_run["legacy_job"], "CBPAUP0J")
+        self.assertGreater(dry_run["purged_count"], 0)
+        applied = self.service.purge_expired_authorizations(current_yyddd=23305, expiry_days=5)
+        self.assertGreater(applied["purged_count"], 0)
+        with self.assertRaises(KeyError):
+            self.service.pending_authorization_summary(1, page_size=10)
+
+    def test_combined_transactions_includes_seed_and_interest_previews(self) -> None:
+        combined = self.service.combined_transactions(limit=1000)
+        self.assertEqual(combined["legacy_job"], "COMBTRAN")
+        self.assertEqual(combined["source_datasets"][0], "AWS.M2.CARDDEMO.TRANSACT.BKUP(0)")
+        self.assertEqual(combined["source_datasets"][1], "AWS.M2.CARDDEMO.SYSTRAN(0)")
+        self.assertEqual(combined["sort"]["symbol"], "TRAN-ID")
+        self.assertEqual(combined["sort"]["start"], 1)
+        self.assertEqual(combined["sort"]["length"], 16)
+        self.assertEqual(combined["sort"]["order"], "A")
+        self.assertEqual(combined["sortout_dataset"], "AWS.M2.CARDDEMO.TRANSACT.COMBINED(+1)")
+        self.assertEqual(combined["repro_target"], "AWS.M2.CARDDEMO.TRANSACT.VSAM.KSDS")
+        self.assertEqual(combined["source_counts"]["transaction_master"], 300)
+        self.assertGreater(combined["source_counts"]["interest_projection"], 0)
+        self.assertEqual(
+            combined["source_counts"]["total_combined"],
+            combined["source_counts"]["transaction_master"] + combined["source_counts"]["interest_projection"],
+        )
+        self.assertEqual(combined["source_counts"]["returned"], len(combined["rows"]))
+        transaction_ids = [row["transaction_id"] for row in combined["rows"]]
+        self.assertEqual(transaction_ids, sorted(transaction_ids))
+
+
+if __name__ == "__main__":
+    unittest.main()

modern_code/tests/test_static_oracle_replay.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+from tools.replay_static_oracles import build_static_oracle_replay, write_json
+
+
+ROOT = Path(__file__).resolve().parents[2]
+SOURCE = ROOT / "source"
+
+
+class StaticOracleReplayTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.tmp = tempfile.TemporaryDirectory()
+        self.tmp_path = Path(self.tmp.name)
+        self.db_path = self.tmp_path / "static_oracle_replay.sqlite"
+
+    def tearDown(self) -> None:
+        self.tmp.cleanup()
+
+    def test_static_oracle_replay_executes_modern_service_against_trace_expectations(self) -> None:
+        report = build_static_oracle_replay(SOURCE, self.db_path, source_head="test-source-head")
+
+        self.assertTrue(report["passed"], report["failed_checks"])
+        self.assertEqual(report["capability_count"], 50)
+        self.assertEqual(report["grade_counts"], {"A": 0, "B": 50, "C": 0, "F": 0})
+        self.assertEqual(report["gap_count"], 0)
+        self.assertEqual(report["runtime_probe_count"], 6)
+        self.assertFalse(report["public_actions_allowed"])
+        self.assertIn("no live COBOL/CICS runtime replay", report["claim_limit"])
+        self.assertEqual(len(report["replay_hash"]), 64)
+
+        probes = {row["trace_id"]: row for row in report["runtime_probes"]}
+        self.assertEqual(
+            probes["mq_system_date_cdrd_reply"]["actual"]["reply_message"],
+            "SYSTEM DATE : 05-23-2026SYSTEM TIME : 11:12:13",
+        )
+        self.assertTrue(probes["mq_account_inquiry_cdra_success_and_invalid"]["actual"]["reply_has_account_label"])
+        self.assertEqual(
+            probes["batch_resource_setup_gdg_vsam_aix_cics"]["actual"]["tranidx_keys"],
+            {"length": 26, "offset": 304},
+        )
+        self.assertEqual(
+            probes["pending_authorization_cp00_request_response_and_insert"]["actual"]["approved_count_delta"],
+            1,
+        )
+
+        output_path = write_json(self.tmp_path / "static_oracle_replay.json", report)
+        loaded = json.loads(output_path.read_text(encoding="utf-8"))
+        self.assertEqual(loaded["replay_hash"], report["replay_hash"])
+
+
+if __name__ == "__main__":
+    unittest.main()

modern_code/tools/build_hf_public_bundle.py

@@ -0,0 +1,394 @@
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import shutil
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+SOURCE_REMOTE = "https://github.com/aws-samples/aws-mainframe-modernization-carddemo.git"
+SOURCE_HEAD = "59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e"
+BUNDLE_VERSION = "carddemo_hf_public_bundle_v0"
+DEFAULT_REPO_ID = "cjc0013/aws-carddemo-no-cost-modernization-proof"
+EXCLUDE_DIRS = {"__pycache__", ".dettools_backups", ".dettools_checkpoints", ".git", "final_proof", "reports"}
+EXCLUDE_SUFFIXES = {".pyc", ".sqlite", ".db", ".log"}
+FINAL_PROOF_FILES = [
+    "FINAL_PROOF_README.md",
+    "FINAL_RECEIPT_SUMMARY.json",
+    "REPRO_COMMANDS.txt",
+    "STATIC_ORACLE_REPLAY_REPORT.json",
+    "KNOWN_LIMITS.md",
+    "ARTIFACT_MANIFEST.json",
+    "A_GRADE_PROMOTION_REPORT.json",
+    "A_GRADE_PROMOTION_README.md",
+    "NO_COST_CONFIDENCE_REPORT.json",
+    "NO_COST_CONFIDENCE_README.md",
+    "CLEAN_REPRO_VERIFICATION.json",
+]
+
+
+def read_json(path: Path) -> Any:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def write_json(path: Path, payload: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2, sort_keys=True, default=str) + "\n", encoding="utf-8")
+
+
+def write_text(path: Path, text: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text.strip() + "\n", encoding="utf-8")
+
+
+def sha256_path(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def stable_hash(payload: Any) -> str:
+    return hashlib.sha256(json.dumps(payload, sort_keys=True, default=str).encode("utf-8")).hexdigest()
+
+
+def clean_dir(path: Path) -> None:
+    resolved = path.resolve()
+    if resolved.anchor == str(resolved):
+        raise ValueError(f"Refusing to clear drive root: {resolved}")
+    if resolved.exists():
+        shutil.rmtree(resolved)
+    resolved.mkdir(parents=True, exist_ok=True)
+
+
+def should_copy_modern_file(path: Path, modern_root: Path) -> bool:
+    rel = path.resolve().relative_to(modern_root.resolve())
+    if any(part in EXCLUDE_DIRS for part in rel.parts):
+        return False
+    if path.suffix.lower() in EXCLUDE_SUFFIXES:
+        return False
+    if rel.parts and rel.parts[0].startswith(".dettools"):
+        return False
+    return path.is_file()
+
+
+def copy_tree_filtered(src_root: Path, dst_root: Path) -> list[dict[str, Any]]:
+    copied = []
+    for path in sorted(src_root.rglob("*")):
+        if not should_copy_modern_file(path, src_root):
+            continue
+        rel = path.resolve().relative_to(src_root.resolve())
+        target = dst_root / rel
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(path, target)
+        copied.append(file_record(target, dst_root))
+    return copied
+
+
+def file_record(path: Path, base: Path) -> dict[str, Any]:
+    return {
+        "path": str(path.resolve().relative_to(base.resolve())).replace("\\", "/"),
+        "size_bytes": path.stat().st_size,
+        "sha256": sha256_path(path),
+    }
+
+
+def collect_files(root: Path) -> list[dict[str, Any]]:
+    return [file_record(path, root) for path in sorted(root.rglob("*")) if path.is_file()]
+
+
+def copy_final_proof(modern_root: Path, bundle_root: Path) -> list[dict[str, Any]]:
+    src = modern_root / "final_proof"
+    dst = bundle_root / "final_proof"
+    copied = []
+    for name in FINAL_PROOF_FILES:
+        source = src / name
+        if not source.exists():
+            continue
+        target = dst / name
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source, target)
+        copied.append(file_record(target, bundle_root))
+    return copied
+
+
+def build_readme(summary: dict[str, Any], no_cost: dict[str, Any], repo_id: str) -> str:
+    no_cost_summary = no_cost["no_cost_confidence_summary"]
+    coverage = no_cost["capability_coverage"]
+    a_gate = summary["a_grade_promotion"]
+    return f"""---
+license: other
+language:
+- en
+tags:
+- mainframe-modernization
+- cobol
+- cics
+- static-analysis
+- verification
+- reproducibility
+- legacy-modernization
+pretty_name: AWS CardDemo No-Cost Modernization Proof
+---
+
+# AWS CardDemo No-Cost Modernization Proof
+
+This repository publishes a reproducible proof bundle for a local modernization run against AWS CardDemo. It is intentionally **not** a claim of live COBOL/CICS all-path runtime equivalence.
+
+Plainly: this is not a claim of live COBOL/CICS all-path runtime equivalence.
+
+The practical claim is narrower and receipt-backed: we pushed the free/no-cost verification path as far as we reasonably could. The remaining validation requires a real or licensed-compatible legacy runtime for COBOL/CICS/VSAM/JCL execution.
+
+In short: without paid/licensed legacy runtime access, this is as far as this proof can honestly go.
+
+## Headline Result
+
+- Reviewer posture: `{no_cost_summary['reviewer_posture']}`
+- Ready for pre-runtime review: `{no_cost_summary['ready_for_pre_runtime_review']}`
+- Current static/source-oracle parity: `B={summary['parity']['B']} / F={summary['parity']['F']} / gaps={summary['parity']['gap_count']}`
+- A-grade live runtime parity: `A={summary['parity']['grade_counts'].get('A', 0)}`
+- A-grade promotion gate: `{a_gate['decision_action']}`
+- A-grade live matches accepted: `{a_gate['accepted_live_matches']}`
+- A-grade live matches missing: `{a_gate['missing_live_matches']}`
+- Paid runtime used: `{no_cost['no_cost_scope']['paid_runtime_used']}`
+- Legacy runtime equivalence claimed: `{no_cost['no_cost_scope']['legacy_runtime_claim_made']}`
+
+## Source Identity
+
+- Upstream source repo: `{SOURCE_REMOTE}`
+- Upstream source commit: `{SOURCE_HEAD}`
+- Source files hashed in receipt: `{summary['source']['source_hash_count']}`
+- Source hash digest: `{summary['source']['source_hashes_digest']}`
+
+The upstream AWS CardDemo source tree is **not copied into this repository**. Clone it from the upstream project at the exact commit above when reproducing.
+
+## Evidence Included
+
+- `final_proof/FINAL_PROOF_README.md`: technical reviewer entry point.
+- `final_proof/FINAL_RECEIPT_SUMMARY.json`: machine-readable receipt summary.
+- `final_proof/NO_COST_CONFIDENCE_REPORT.json`: no-cost confidence evidence and methodology.
+- `final_proof/A_GRADE_PROMOTION_REPORT.json`: strict A-grade gate and why it does not promote without live traces.
+- `final_proof/STATIC_ORACLE_REPLAY_REPORT.json`: executable modern replay over static/source-derived oracles.
+- `METHODOLOGY.md`: evidence method and proof boundaries.
+- `REPRODUCIBILITY.md`: one-command local checks.
+- `DUE_DILIGENCE.md`: quick reviewer checklist.
+- `modern_code/`: modern Python/SQLite implementation snapshot and proof tooling.
+
+## No-Cost Evidence Summary
+
+- Capability count: `{coverage['capability_count']}`
+- Static/source-oracle-ready capabilities: `{coverage['static_oracle_ready_count']}`
+- Capability source references: `{coverage['source_ref_total']}`
+- Golden traces: `{no_cost['fixture_corpus']['golden_trace_count']}`
+- Edge cases: `{no_cost['fixture_corpus']['edge_case_count']}`
+- COBOL programs scanned: `{no_cost['legacy_source_semantics_scan']['cobol_program_count']}`
+- CICS programs identified: `{no_cost['legacy_source_semantics_scan']['cics_program_count']}`
+- Free GnuCOBOL probe candidates: `{no_cost['legacy_source_semantics_scan']['free_gnucobol_probe_candidate_count']}`
+
+## The Unpaid Boundary
+
+We cannot honestly push this to live runtime parity without access to a real or licensed-compatible legacy execution environment. That means one of:
+
+- AWS Mainframe Modernization runtime access,
+- Micro Focus / Enterprise Server-style runtime access,
+- UniKix or equivalent runtime access,
+- a real z/OS/CICS/VSAM/JCL endpoint,
+- or another compatible environment capable of executing the original legacy paths.
+
+Without that, the correct remaining statement is: the modernization is strongly supported by source-derived static oracles and executable modern replay, but final production-equivalence validation must happen on the legacy runtime owner’s environment.
+
+## Repository Type
+
+This is published as a Hugging Face dataset-style proof artifact, not a trained model and not a hosted runtime.
+
+HF repo target used for staging: `{repo_id}`
+"""
+
+
+def build_methodology(summary: dict[str, Any], no_cost: dict[str, Any]) -> str:
+    return f"""
+# Methodology
+
+## Goal
+
+Produce the strongest practical modernization proof possible without paid or licensed legacy runtime infrastructure.
+
+## Method
+
+1. Pin the upstream AWS CardDemo source repository and commit.
+2. Hash the source files and generated modern files.
+3. Extract capabilities from legacy source, copybooks, BMS maps, JCL, seed data, and static contracts.
+4. Build a one-for-one capability ledger.
+5. Implement the modern Python/SQLite target against those source-derived contracts.
+6. Generate receipts, golden traces, edge cases, and parity reports.
+7. Execute the modern service against static/source-oracle replay checks.
+8. Run clean-copy reproduction and API smoke checks.
+9. Run a strict A-grade gate that refuses promotion without live legacy runtime traces.
+10. Publish the evidence with explicit boundaries.
+
+## Current Proof State
+
+- B-grade static/source-oracle capabilities: `{summary['parity']['B']}`
+- F-grade gaps: `{summary['parity']['F']}`
+- Gap count: `{summary['parity']['gap_count']}`
+- Static replay passed: `{summary['static_oracle_replay']['passed']}`
+- No-cost confidence posture: `{no_cost['no_cost_confidence_summary']['reviewer_posture']}`
+- A-grade promotable: `{summary['a_grade_promotion']['promotable_to_A']}`
+
+## What Would Upgrade This To A
+
+The A-grade gate requires accepted live legacy runtime trace records for every capability. Each record must bind a capability ID to the pinned source head, a live runtime trace kind, a raw legacy trace hash, a modern observation hash, a comparator version, and `matched=true`.
+
+The current bundle has zero accepted live runtime matches because no paid/licensed legacy runtime was executed.
+"""
+
+
+def build_due_diligence(summary: dict[str, Any], repo_id: str) -> str:
+    return f"""
+# Basic Due Diligence
+
+Clone this HF repository and inspect:
+
+1. `README.md`
+2. `final_proof/FINAL_PROOF_README.md`
+3. `final_proof/NO_COST_CONFIDENCE_README.md`
+4. `final_proof/A_GRADE_PROMOTION_README.md`
+
+Then clone the upstream AWS source next to `modern_code`:
+
+```powershell
+git clone {SOURCE_REMOTE} source
+git -C source checkout {SOURCE_HEAD}
+```
+
+From `modern_code`, run:
+
+```powershell
+python -m unittest discover -s tests
+python tools\\replay_static_oracles.py --source-root ..\\source --out-dir .\\reports --source-head {SOURCE_HEAD}
+python tools\\build_no_cost_confidence.py --source-root ..\\source --out-dir .\\final_proof
+python tools\\evaluate_a_grade_promotion.py --source-root ..\\source --out-dir .\\final_proof
+```
+
+Expected high-level result:
+
+- tests pass,
+- static replay returns `"passed": true`,
+- no-cost confidence returns `"reviewer_posture": "strong_pre_runtime_confidence"`,
+- A-grade gate returns `"promotable_to_A": false`.
+
+That last result is intentional: `{repo_id}` does not claim live COBOL/CICS runtime parity.
+"""
+
+
+def build_reproducibility(summary: dict[str, Any]) -> str:
+    source_head = summary["source"]["head"]
+    return f"""
+# Reproducibility
+
+This bundle is reproducible with no paid legacy runtime, but it still requires cloning the upstream AWS source at the pinned commit.
+
+```powershell
+git clone {SOURCE_REMOTE} source
+git -C source checkout {source_head}
+cd modern_code
+powershell -NoProfile -Command "python -m carddemo.cli init-db --source-root ..\\source --db-path .\\carddemo.sqlite; python -m unittest discover -s tests; python tools\\generate_receipts.py --source-root ..\\source --db-path .\\carddemo.sqlite --out-dir .\\reports; python tools\\replay_static_oracles.py --source-root ..\\source --out-dir .\\reports --source-head {source_head}; python tools\\evaluate_a_grade_promotion.py --source-root ..\\source --out-dir .\\final_proof; python tools\\build_no_cost_confidence.py --source-root ..\\source --out-dir .\\final_proof; python tools\\package_final_proof.py --source-root ..\\source"
+```
+
+For clean-copy reproduction, run:
+
+```powershell
+python tools\\verify_clean_repro.py --modern-root . --source-root ..\\source
+```
+"""
+
+
+def build_publication_notes() -> str:
+    return """
+# Publication Notes
+
+- This is a proof artifact, not a production migration recommendation.
+- The original AWS CardDemo source tree is not redistributed here.
+- The modern code snapshot is provided for review of the local modernization artifact.
+- The proof explicitly avoids claiming live COBOL/CICS equivalence.
+- The phrase "strong pre-runtime confidence" means the no-cost checks passed; it does not mean production acceptance.
+- Further proof requires paid/licensed or customer-owned legacy runtime access.
+"""
+
+
+def build_bundle(modern_root: Path, out_dir: Path, repo_id: str) -> dict[str, Any]:
+    modern_root = modern_root.resolve()
+    out_dir = out_dir.resolve()
+    final_proof = modern_root / "final_proof"
+    summary = read_json(final_proof / "FINAL_RECEIPT_SUMMARY.json")
+    no_cost = read_json(final_proof / "NO_COST_CONFIDENCE_REPORT.json")
+
+    clean_dir(out_dir)
+    write_text(out_dir / "README.md", build_readme(summary, no_cost, repo_id))
+    write_text(out_dir / "METHODOLOGY.md", build_methodology(summary, no_cost))
+    write_text(out_dir / "DUE_DILIGENCE.md", build_due_diligence(summary, repo_id))
+    write_text(out_dir / "REPRODUCIBILITY.md", build_reproducibility(summary))
+    write_text(out_dir / "PUBLICATION_NOTES.md", build_publication_notes())
+    proof_files = copy_final_proof(modern_root, out_dir)
+    modern_files = copy_tree_filtered(modern_root, out_dir / "modern_code")
+
+    manifest = {
+        "bundle_version": BUNDLE_VERSION,
+        "generated_utc": datetime.now(timezone.utc).replace(microsecond=0).isoformat(),
+        "hf_repo_id": repo_id,
+        "source_repo": SOURCE_REMOTE,
+        "source_head": SOURCE_HEAD,
+        "claim_boundary": "No live COBOL/CICS all-path runtime equivalence is claimed.",
+        "proof_summary": {
+            "B": summary["parity"]["B"],
+            "F": summary["parity"]["F"],
+            "gaps": summary["parity"]["gap_count"],
+            "no_cost_reviewer_posture": summary["no_cost_confidence"]["reviewer_posture"],
+            "a_promotable": summary["a_grade_promotion"]["promotable_to_A"],
+        },
+        "proof_file_count": len(proof_files),
+        "modern_snapshot_file_count": len(modern_files),
+        "files": collect_files(out_dir),
+        "public_safe_checks": {
+            "original_source_tree_copied": False,
+            "paid_runtime_claim_made": False,
+            "live_runtime_equivalence_claim_made": False,
+        },
+    }
+    manifest["manifest_hash"] = stable_hash(manifest)
+    write_json(out_dir / "HF_PUBLICATION_MANIFEST.json", manifest)
+    manifest["files"] = collect_files(out_dir)
+    manifest["manifest_hash"] = stable_hash(manifest)
+    write_json(out_dir / "HF_PUBLICATION_MANIFEST.json", manifest)
+    return manifest
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Build HF-ready public proof bundle")
+    parser.add_argument("--modern-root", type=Path, default=Path(__file__).resolve().parents[1])
+    parser.add_argument("--out-dir", type=Path, required=True)
+    parser.add_argument("--repo-id", default=DEFAULT_REPO_ID)
+    args = parser.parse_args()
+
+    manifest = build_bundle(args.modern_root, args.out_dir, args.repo_id)
+    print(
+        json.dumps(
+            {
+                "out_dir": str(args.out_dir.resolve()),
+                "hf_repo_id": args.repo_id,
+                "file_count": len(manifest["files"]),
+                "manifest_hash": manifest["manifest_hash"],
+                "proof_summary": manifest["proof_summary"],
+            },
+            indent=2,
+            sort_keys=True,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

modern_code/tools/build_no_cost_confidence.py

@@ -0,0 +1,441 @@
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+import shutil
+import subprocess
+from collections import Counter
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+SOURCE_REMOTE = "https://github.com/aws-samples/aws-mainframe-modernization-carddemo.git"
+SOURCE_HEAD = "59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e"
+REPORT_VERSION = "carddemo_no_cost_confidence_v0"
+README_VERSION = "carddemo_no_cost_confidence_readme_v0"
+CLAIM_BOUNDARY = (
+    "Maximum no-cost confidence evidence only. This is not live COBOL/CICS all-path runtime equivalence."
+)
+TOOL_PROBES = {
+    "cobc": "Free COBOL compiler probe for isolated non-CICS COBOL logic.",
+    "docker": "Container runtime probe; useful only if a runnable legacy runtime image is available.",
+    "aws": "AWS runtime path probe; not required for no-cost proof and not used here.",
+    "java": "JVM probe for possible migration/runtime tools.",
+    "mvn": "Maven probe for Java tooling.",
+    "gradle": "Gradle probe for Java tooling.",
+    "hercules": "Mainframe emulator probe; not sufficient by itself for CICS/VSAM/JCL.",
+    "tn3270": "3270 terminal probe for live CICS transaction capture.",
+}
+
+
+def read_json(path: Path, default: Any = None) -> Any:
+    if not path.exists():
+        return default
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def write_json(path: Path, payload: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2, sort_keys=True, default=str) + "\n", encoding="utf-8")
+
+
+def write_text(path: Path, text: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text.strip() + "\n", encoding="utf-8")
+
+
+def stable_hash(payload: Any) -> str:
+    return hashlib.sha256(json.dumps(payload, sort_keys=True, default=str).encode("utf-8")).hexdigest()
+
+
+def sha256_path(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def path_record(path: Path, base: Path) -> dict[str, Any]:
+    return {
+        "path": str(path.resolve().relative_to(base.resolve())).replace("\\", "/"),
+        "size_bytes": path.stat().st_size,
+        "sha256": sha256_path(path),
+    }
+
+
+def probe_tool(name: str) -> dict[str, Any]:
+    resolved = shutil.which(name)
+    result = {
+        "tool": name,
+        "present": resolved is not None,
+        "path": resolved,
+        "why_checked": TOOL_PROBES[name],
+    }
+    if not resolved:
+        return result
+    args = [resolved, "--version"]
+    if name == "docker":
+        args = [resolved, "version", "--format", "{{json .Server.Version}}"]
+    try:
+        completed = subprocess.run(args, check=False, capture_output=True, text=True, timeout=8)
+    except Exception as exc:  # pragma: no cover - environment dependent
+        result.update({"version_probe_ok": False, "version_probe_error": str(exc)})
+        return result
+    output = (completed.stdout or completed.stderr or "").strip()
+    result.update(
+        {
+            "version_probe_ok": completed.returncode == 0,
+            "version_probe_returncode": completed.returncode,
+            "version_probe_output": output[:500],
+        }
+    )
+    return result
+
+
+def source_file_inventory(source_root: Path) -> dict[str, Any]:
+    app_root = source_root / "app"
+    files = [path for path in app_root.rglob("*") if path.is_file()]
+    by_suffix = Counter(path.suffix.lower() or "<none>" for path in files)
+    evidence_suffixes = {".cbl", ".cpy", ".bms", ".jcl", ".dat", ".txt"}
+    evidence_files = [path_record(path, source_root) for path in files if path.suffix.lower() in evidence_suffixes]
+    return {
+        "app_root": str(app_root.resolve()),
+        "file_count": len(files),
+        "extension_counts": dict(sorted(by_suffix.items())),
+        "evidence_file_count": len(evidence_files),
+        "evidence_file_hash_digest": stable_hash(evidence_files),
+    }
+
+
+def classify_cobol_program(path: Path, source_root: Path) -> dict[str, Any]:
+    text = path.read_text(encoding="utf-8", errors="ignore")
+    upper = text.upper()
+    has_cics = bool(re.search(r"\bEXEC\s+CICS\b", upper))
+    has_sql = bool(re.search(r"\bEXEC\s+SQL\b", upper))
+    has_dli = bool(re.search(r"\bEXEC\s+DLI\b", upper))
+    has_mq = " MQ" in upper or "MQ" in path.name.upper()
+    has_file_io = bool(re.search(r"\b(SELECT|FD|READ|WRITE|REWRITE|DELETE|START)\b", upper))
+    has_vsam_shape = bool(
+        re.search(r"\b(KSDS|ESDS|RRDS|VSAM|ORGANIZATION\s+IS\s+INDEXED|ACCESS\s+MODE)\b", upper)
+    )
+    cics_ops = sorted(set(re.findall(r"\b(?:READNEXT|STARTBR|ENDBR|READ|WRITE|REWRITE|DELETE|LINK|XCTL|RETURN|SEND|RECEIVE)\b", upper)))
+    return {
+        "path": str(path.resolve().relative_to(source_root.resolve())).replace("\\", "/"),
+        "line_count": len(text.splitlines()),
+        "has_cics": has_cics,
+        "has_sql": has_sql,
+        "has_dli": has_dli,
+        "has_mq_hint": has_mq,
+        "has_file_io": has_file_io,
+        "has_vsam_shape": has_vsam_shape,
+        "cics_operation_hints": cics_ops if has_cics else [],
+        "free_compile_feasibility": (
+            "possible_isolated_gnucobol_probe"
+            if not has_cics and not has_sql and not has_dli and not has_mq
+            else "requires_mainframe_or_compatible_runtime"
+        ),
+    }
+
+
+def legacy_source_semantics_scan(source_root: Path) -> dict[str, Any]:
+    program_map: dict[str, Path] = {}
+    for pattern in ("*.cbl", "*.CBL"):
+        for path in (source_root / "app").rglob(pattern):
+            program_map[str(path.resolve()).lower()] = path
+    programs = sorted(program_map.values(), key=lambda path: str(path).lower())
+    classified = [classify_cobol_program(path, source_root) for path in programs]
+    cics_programs = [item for item in classified if item["has_cics"]]
+    free_probe_candidates = [item for item in classified if item["free_compile_feasibility"] == "possible_isolated_gnucobol_probe"]
+    return {
+        "cobol_program_count": len(classified),
+        "cics_program_count": len(cics_programs),
+        "non_cics_cobol_count": len(classified) - len(cics_programs),
+        "free_gnucobol_probe_candidate_count": len(free_probe_candidates),
+        "free_gnucobol_probe_candidate_paths": [item["path"] for item in free_probe_candidates[:25]],
+        "runtime_required_program_count": len([item for item in classified if item["free_compile_feasibility"] == "requires_mainframe_or_compatible_runtime"]),
+        "programs": classified,
+    }
+
+
+def capability_coverage(ledger: list[dict[str, Any]]) -> dict[str, Any]:
+    source_ref_counts = [int(item.get("source_ref_count", 0)) for item in ledger]
+    surfaces = Counter(str(item.get("surface") or "unknown") for item in ledger)
+    grades = Counter(str(item.get("proof_grade") or "unknown") for item in ledger)
+    static_ready = sum(1 for item in ledger if item.get("static_oracle_ready") is True)
+    strict_ready = sum(1 for item in ledger if item.get("strict_parity_ready") is True)
+    zero_ref_ids = [item.get("capability_id") for item in ledger if int(item.get("source_ref_count", 0)) <= 0]
+    return {
+        "capability_count": len(ledger),
+        "surface_counts": dict(sorted(surfaces.items())),
+        "proof_grade_counts": dict(sorted(grades.items())),
+        "static_oracle_ready_count": static_ready,
+        "strict_runtime_ready_count": strict_ready,
+        "source_ref_total": sum(source_ref_counts),
+        "source_ref_min": min(source_ref_counts) if source_ref_counts else 0,
+        "source_ref_max": max(source_ref_counts) if source_ref_counts else 0,
+        "zero_source_ref_capability_ids": zero_ref_ids,
+        "all_have_source_refs": not zero_ref_ids,
+        "all_static_oracle_ready": static_ready == len(ledger),
+    }
+
+
+def final_proof_status(modern_root: Path, out_dir: Path) -> dict[str, Any]:
+    final_summary = read_json(out_dir / "FINAL_RECEIPT_SUMMARY.json", {})
+    clean = read_json(out_dir / "CLEAN_REPRO_VERIFICATION.json", {})
+    return {
+        "final_summary_present": bool(final_summary),
+        "clean_repro_present": bool(clean),
+        "clean_repro_passed": clean.get("passed"),
+        "api_smoke_passed": clean.get("api_smoke_passed"),
+        "screenshot_present": (modern_root / "reports" / "ui_batch_reports_smoke.png").exists(),
+        "screenshot_sha256": sha256_path(modern_root / "reports" / "ui_batch_reports_smoke.png")
+        if (modern_root / "reports" / "ui_batch_reports_smoke.png").exists()
+        else None,
+    }
+
+
+def confidence_layers(
+    receipt: dict[str, Any],
+    replay: dict[str, Any],
+    a_grade: dict[str, Any],
+    coverage: dict[str, Any],
+    final_status: dict[str, Any],
+) -> list[dict[str, Any]]:
+    parity = receipt.get("capability_parity", {})
+    grade_counts = parity.get("grade_counts", {})
+    a_gate = a_grade.get("a_grade_gate", {})
+    layers = [
+        {
+            "layer": "source_identity_and_hashes",
+            "status": "pass" if receipt.get("source_hash_count", 0) > 0 and receipt.get("source_head") == SOURCE_HEAD else "fail",
+            "detail": f"source_head={receipt.get('source_head')} source_hash_count={receipt.get('source_hash_count')}",
+        },
+        {
+            "layer": "one_for_one_capability_ledger",
+            "status": "pass" if parity.get("capability_count") == 50 and grade_counts.get("B") == 50 and parity.get("gap_count") == 0 else "fail",
+            "detail": f"capabilities={parity.get('capability_count')} B={grade_counts.get('B')} gaps={parity.get('gap_count')}",
+        },
+        {
+            "layer": "source_reference_coverage",
+            "status": "pass" if coverage["all_have_source_refs"] and coverage["all_static_oracle_ready"] else "fail",
+            "detail": f"source_refs={coverage['source_ref_total']} static_ready={coverage['static_oracle_ready_count']}",
+        },
+        {
+            "layer": "executable_static_oracle_replay",
+            "status": "pass" if replay.get("passed") and not replay.get("failed_checks") else "fail",
+            "detail": f"runtime_probe_count={replay.get('runtime_probe_count')} failed_checks={len(replay.get('failed_checks', []))}",
+        },
+        {
+            "layer": "edge_case_and_golden_trace_corpus",
+            "status": "pass" if replay.get("edge_case_count", 0) > 0 and replay.get("golden_trace_count", 0) > 0 else "fail",
+            "detail": f"edge_cases={replay.get('edge_case_count')} golden_traces={replay.get('golden_trace_count')}",
+        },
+        {
+            "layer": "clean_copy_reproduction_and_api_smoke",
+            "status": "pass" if final_status["clean_repro_passed"] and final_status["api_smoke_passed"] else "warn",
+            "detail": f"clean_repro={final_status['clean_repro_passed']} api_smoke={final_status['api_smoke_passed']}",
+        },
+        {
+            "layer": "honest_a_grade_runtime_gate",
+            "status": "pass" if a_gate.get("promotable_to_A") is False and a_gate.get("missing_live_matches") == 50 else "warn",
+            "detail": (
+                f"promotable_to_A={a_gate.get('promotable_to_A')} "
+                f"accepted_live={a_gate.get('accepted_live_matches')} missing_live={a_gate.get('missing_live_matches')}"
+            ),
+        },
+    ]
+    return layers
+
+
+def build_no_cost_confidence_report(modern_root: Path, source_root: Path, out_dir: Path) -> dict[str, Any]:
+    modern_root = modern_root.resolve()
+    source_root = source_root.resolve()
+    out_dir = out_dir.resolve()
+    reports = modern_root / "reports"
+    receipt = read_json(reports / "modernization_receipt.json", {})
+    ledger = read_json(reports / "capability_ledger.json", [])
+    replay = read_json(reports / "static_oracle_replay.json", {})
+    edge_cases = read_json(reports / "edge_cases.json", [])
+    golden_traces = read_json(reports / "golden_traces.json", [])
+    a_grade = read_json(out_dir / "A_GRADE_PROMOTION_REPORT.json", {})
+
+    inventory = source_file_inventory(source_root)
+    semantics_scan = legacy_source_semantics_scan(source_root)
+    coverage = capability_coverage(ledger)
+    final_status = final_proof_status(modern_root, out_dir)
+    layers = confidence_layers(receipt, replay, a_grade, coverage, final_status)
+    counts = Counter(layer["status"] for layer in layers)
+    no_cost_ready = counts.get("fail", 0) == 0 and counts.get("pass", 0) >= 6
+
+    report: dict[str, Any] = {
+        "report_version": REPORT_VERSION,
+        "generated_utc": datetime.now(timezone.utc).replace(microsecond=0).isoformat(),
+        "source": {
+            "repo_url": SOURCE_REMOTE,
+            "head": SOURCE_HEAD,
+            "local_path": str(source_root),
+        },
+        "modern_code": {
+            "local_path": str(modern_root),
+        },
+        "claim_boundary": CLAIM_BOUNDARY,
+        "no_cost_scope": {
+            "paid_runtime_used": False,
+            "public_actions_allowed": False,
+            "legacy_runtime_claim_made": False,
+            "goal": (
+                "Produce the strongest practical pre-runtime evidence without paid/licensed legacy infrastructure, "
+                "then leave only live legacy runtime validation as the named residual gap."
+            ),
+        },
+        "source_inventory": inventory,
+        "legacy_source_semantics_scan": semantics_scan,
+        "capability_coverage": coverage,
+        "static_oracle_replay": {
+            "present": bool(replay),
+            "passed": replay.get("passed"),
+            "replay_hash": replay.get("replay_hash"),
+            "evidence_hash": replay.get("evidence_hash"),
+            "runtime_probe_count": replay.get("runtime_probe_count"),
+            "failed_checks": replay.get("failed_checks", []),
+            "claim_limit": replay.get("claim_limit"),
+        },
+        "test_and_smoke_evidence": final_status,
+        "fixture_corpus": {
+            "edge_case_count": len(edge_cases),
+            "golden_trace_count": len(golden_traces),
+            "edge_case_hash": stable_hash(edge_cases),
+            "golden_trace_hash": stable_hash(golden_traces),
+        },
+        "local_runtime_feasibility": {
+            "tooling_probe": {name: probe_tool(name) for name in TOOL_PROBES},
+            "conclusion": (
+                "Free/local analysis can inspect, parse, hash, replay extracted expectations, and optionally probe "
+                "isolated non-CICS COBOL if cobc is available. It cannot honestly replace CICS/VSAM/JCL execution."
+            ),
+        },
+        "a_grade_gate": {
+            "present": bool(a_grade),
+            "decision": (a_grade.get("decision") or {}).get("action"),
+            "promotable_to_A": (a_grade.get("a_grade_gate") or {}).get("promotable_to_A"),
+            "required_live_matches": (a_grade.get("a_grade_gate") or {}).get("required_live_matches"),
+            "accepted_live_matches": (a_grade.get("a_grade_gate") or {}).get("accepted_live_matches"),
+            "missing_live_matches": (a_grade.get("a_grade_gate") or {}).get("missing_live_matches"),
+            "report_hash": a_grade.get("report_hash"),
+        },
+        "no_cost_confidence_layers": layers,
+        "no_cost_confidence_summary": {
+            "status_counts": dict(sorted(counts.items())),
+            "ready_for_pre_runtime_review": no_cost_ready,
+            "reviewer_posture": "strong_pre_runtime_confidence" if no_cost_ready else "needs_more_no_cost_evidence",
+            "remaining_gap": "live legacy COBOL/CICS/VSAM/JCL runtime validation on a real or licensed-compatible runtime",
+            "plain_english": (
+                "The modern app is strongly supported by source-derived static oracles, executable modern replay, "
+                "edge cases, clean-copy tests, and API smoke. A reviewer should still require live legacy runtime "
+                "validation before accepting production equivalence."
+            ),
+        },
+        "reviewer_language": {
+            "what_this_should_convince": [
+                "The modernization has a pinned source identity and hashed evidence base.",
+                "Every tracked capability has source-backed static/source-oracle coverage.",
+                "The modern service executes against legacy-derived fixtures without current gaps.",
+                "The remaining risk is specifically runtime-environment validation, not a known missing feature in the current rubric.",
+            ],
+            "what_this_cannot_claim": [
+                "It cannot claim all-path live COBOL/CICS equivalence.",
+                "It cannot prove CICS, VSAM, JCL, DB2, IMS, MQ, or terminal behavior that only appears in a paid or hosted runtime.",
+                "It cannot remove the need for final validation in the customer's legacy runtime environment.",
+            ],
+        },
+        "public_actions_allowed": False,
+    }
+    report["report_hash"] = stable_hash(report)
+    return report
+
+
+def confidence_readme(report: dict[str, Any]) -> str:
+    summary = report["no_cost_confidence_summary"]
+    coverage = report["capability_coverage"]
+    semantics = report["legacy_source_semantics_scan"]
+    replay = report["static_oracle_replay"]
+    a_gate = report["a_grade_gate"]
+    return f"""
+# AWS CardDemo No-Cost Confidence Proof
+
+Report version: `{README_VERSION}`
+
+This artifact answers the practical question: how far did we get without paying for or depending on a licensed legacy runtime?
+
+## Result
+
+- Reviewer posture: `{summary['reviewer_posture']}`
+- Ready for pre-runtime review: `{summary['ready_for_pre_runtime_review']}`
+- Paid runtime used: `False`
+- Public actions allowed: `False`
+- Remaining gap: `{summary['remaining_gap']}`
+
+## Evidence We Can Produce For Free
+
+- Capability coverage: `{coverage['capability_count']}` capabilities.
+- Static/source-oracle ready: `{coverage['static_oracle_ready_count']}` capabilities.
+- Source references attached to capability ledger: `{coverage['source_ref_total']}`.
+- Static replay passed: `{replay['passed']}`.
+- Static replay hash: `{replay['replay_hash']}`.
+- Golden traces: `{report['fixture_corpus']['golden_trace_count']}`.
+- Edge cases: `{report['fixture_corpus']['edge_case_count']}`.
+- Clean-copy/API smoke evidence is recorded in `FINAL_RECEIPT_SUMMARY.json`.
+
+## Legacy Source Runtime Shape
+
+- COBOL programs scanned: `{semantics['cobol_program_count']}`.
+- CICS programs: `{semantics['cics_program_count']}`.
+- Non-CICS COBOL programs: `{semantics['non_cics_cobol_count']}`.
+- Free GnuCOBOL probe candidates: `{semantics['free_gnucobol_probe_candidate_count']}`.
+- Programs still requiring mainframe-compatible runtime for honest execution: `{semantics['runtime_required_program_count']}`.
+
+## A-Grade Boundary
+
+- A-grade decision: `{a_gate['decision']}`.
+- Promotable to A: `{a_gate['promotable_to_A']}`.
+- Accepted live runtime matches: `{a_gate['accepted_live_matches']}`.
+- Missing live runtime matches: `{a_gate['missing_live_matches']}`.
+
+This does not pretend to be live COBOL/CICS equivalence. It shows that the unpaid work is strong and that the remaining proof step is specifically live legacy runtime validation.
+"""
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Build the no-cost CardDemo confidence proof")
+    parser.add_argument("--modern-root", type=Path, default=Path(__file__).resolve().parents[1])
+    parser.add_argument("--source-root", type=Path, default=Path(__file__).resolve().parents[2] / "source")
+    parser.add_argument("--out-dir", type=Path, default=None)
+    args = parser.parse_args()
+
+    modern_root = args.modern_root.resolve()
+    source_root = args.source_root.resolve()
+    out_dir = (args.out_dir or modern_root / "final_proof").resolve()
+    report = build_no_cost_confidence_report(modern_root, source_root, out_dir)
+    write_json(out_dir / "NO_COST_CONFIDENCE_REPORT.json", report)
+    write_text(out_dir / "NO_COST_CONFIDENCE_README.md", confidence_readme(report))
+    print(
+        json.dumps(
+            {
+                "out_dir": str(out_dir),
+                "reviewer_posture": report["no_cost_confidence_summary"]["reviewer_posture"],
+                "ready_for_pre_runtime_review": report["no_cost_confidence_summary"]["ready_for_pre_runtime_review"],
+                "status_counts": report["no_cost_confidence_summary"]["status_counts"],
+                "report_hash": report["report_hash"],
+            },
+            indent=2,
+            sort_keys=True,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

modern_code/tools/evaluate_a_grade_promotion.py

@@ -0,0 +1,501 @@
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import shutil
+import subprocess
+import zipfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+SOURCE_REMOTE = "https://github.com/aws-samples/aws-mainframe-modernization-carddemo.git"
+SOURCE_HEAD = "59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e"
+REPORT_VERSION = "carddemo_a_grade_promotion_gate_v0"
+README_VERSION = "carddemo_a_grade_promotion_readme_v0"
+ACCEPTED_TRACE_KINDS = {"live_cobol_cics_runtime", "live_mainframe_runtime"}
+TRACE_HASH_FIELDS = ("raw_legacy_trace_hash", "legacy_runtime_trace_hash")
+REQUIRED_TRACE_FIELDS = (
+    "capability_id",
+    "trace_kind",
+    "source_head",
+    "legacy_runtime_environment",
+    "modern_observation_hash",
+    "comparator_version",
+)
+RUNTIME_TOOL_PROBES = {
+    "cobc": "GnuCOBOL compiler; useful for limited COBOL probes, not sufficient for CICS/VSAM/JCL parity.",
+    "aws": "AWS CLI; needed for AWS-hosted M2/Mainframe runtime paths.",
+    "java": "JVM; required by several migration/runtime toolchains.",
+    "mvn": "Maven; useful for Java-based runtime harnesses.",
+    "gradle": "Gradle; useful for Java-based runtime harnesses.",
+    "hercules": "Mainframe emulator; still not a CICS/VSAM/JCL runtime by itself.",
+    "tn3270": "3270 terminal client; useful for interactive CICS transaction capture.",
+    "docker": "Container runtime; useful only when a licensed/runnable legacy runtime image exists.",
+}
+M2_RUNTIME_ZIPS = (
+    Path("samples/m2/mf/CardDemo_runtime.zip"),
+    Path("samples/m2/unikix/UniKix_CardDemo_runtime_v1.zip"),
+)
+
+
+def read_json(path: Path) -> Any:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def write_json(path: Path, payload: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2, sort_keys=True, default=str) + "\n", encoding="utf-8")
+
+
+def write_text(path: Path, text: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text.strip() + "\n", encoding="utf-8")
+
+
+def stable_hash(payload: Any) -> str:
+    return hashlib.sha256(json.dumps(payload, sort_keys=True, default=str).encode("utf-8")).hexdigest()
+
+
+def sha256_path(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def is_sha256(value: Any) -> bool:
+    if not isinstance(value, str) or len(value) != 64:
+        return False
+    return all(ch in "0123456789abcdefABCDEF" for ch in value)
+
+
+def load_capability_ledger(modern_root: Path) -> list[dict[str, Any]]:
+    ledger = read_json(modern_root / "reports" / "capability_ledger.json")
+    if not isinstance(ledger, list):
+        raise ValueError("capability_ledger.json must be a list")
+    return [dict(item) for item in ledger]
+
+
+def load_current_parity(modern_root: Path) -> dict[str, Any]:
+    receipt = read_json(modern_root / "reports" / "modernization_receipt.json")
+    parity = dict(receipt["capability_parity"])
+    parity["receipt_hash"] = receipt["receipt_hash"]
+    parity["source_head"] = receipt["source_head"]
+    parity["receipt_generated_utc"] = receipt["generated_utc"]
+    return parity
+
+
+def command_probe(executable: str) -> dict[str, Any]:
+    resolved = shutil.which(executable)
+    result: dict[str, Any] = {
+        "tool": executable,
+        "present": resolved is not None,
+        "path": resolved,
+        "purpose": RUNTIME_TOOL_PROBES[executable],
+    }
+    if not resolved:
+        return result
+
+    version_args = [resolved, "--version"]
+    if executable == "docker":
+        version_args = [resolved, "version", "--format", "{{json .Server.Version}}"]
+
+    try:
+        completed = subprocess.run(
+            version_args,
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=8,
+        )
+    except Exception as exc:  # pragma: no cover - environment dependent
+        result.update({"version_probe_ok": False, "version_probe_error": str(exc)})
+        return result
+
+    output = (completed.stdout or completed.stderr or "").strip()
+    result.update(
+        {
+            "version_probe_ok": completed.returncode == 0,
+            "version_probe_returncode": completed.returncode,
+            "version_probe_output": output[:500],
+        }
+    )
+    return result
+
+
+def inspect_zip(path: Path) -> dict[str, Any]:
+    record: dict[str, Any] = {
+        "path": str(path.resolve()),
+        "exists": path.exists(),
+        "size_bytes": path.stat().st_size if path.exists() else None,
+        "sha256": sha256_path(path) if path.exists() else None,
+    }
+    if not path.exists():
+        return record
+
+    with zipfile.ZipFile(path) as archive:
+        names = archive.namelist()
+    lowered = [name.replace("\\", "/").lower() for name in names]
+    record.update(
+        {
+            "entry_count": len(names),
+            "sample_entries": names[:30],
+            "has_shared_load_modules": any("/loadlib/" in name and name.endswith(".so") for name in lowered),
+            "has_app_config": any(name.endswith("app_config.json") for name in lowered),
+            "has_catalog_jcl": any("/catalog/jcl/" in name for name in lowered),
+            "has_catalog_data": any("/catalog/data/" in name for name in lowered),
+            "has_unikix_layout": any("unikix" in name or "/migrated_app/" in name for name in lowered),
+            "runtime_conclusion": (
+                "Deployment/runtime asset detected. This is useful provenance, but it is not a live "
+                "executed COBOL/CICS trace corpus by itself."
+            ),
+        }
+    )
+    return record
+
+
+def inspect_runtime_assets(source_root: Path) -> list[dict[str, Any]]:
+    return [inspect_zip(source_root / relative) for relative in M2_RUNTIME_ZIPS]
+
+
+def trace_candidates(payload: Any) -> list[dict[str, Any]]:
+    if isinstance(payload, list):
+        return [item for item in payload if isinstance(item, dict)]
+    if not isinstance(payload, dict):
+        return []
+    candidates: list[dict[str, Any]] = []
+    if "capability_id" in payload:
+        candidates.append(payload)
+    for key in ("capability_matches", "matches", "traces", "results"):
+        value = payload.get(key)
+        if isinstance(value, list):
+            candidates.extend(item for item in value if isinstance(item, dict))
+    return candidates
+
+
+def validate_trace_record(record: dict[str, Any], required_ids: set[str]) -> tuple[bool, list[str]]:
+    reasons: list[str] = []
+    capability_id = record.get("capability_id")
+    if capability_id not in required_ids:
+        reasons.append("unknown_or_missing_capability_id")
+    for field in REQUIRED_TRACE_FIELDS:
+        if not record.get(field):
+            reasons.append(f"missing_{field}")
+    if record.get("trace_kind") not in ACCEPTED_TRACE_KINDS:
+        reasons.append("trace_kind_not_live_legacy_runtime")
+    if record.get("source_head") != SOURCE_HEAD:
+        reasons.append("source_head_mismatch")
+    if record.get("matched") is not True:
+        reasons.append("matched_not_true")
+    legacy_hash = next((record.get(field) for field in TRACE_HASH_FIELDS if record.get(field)), None)
+    if not legacy_hash:
+        reasons.append("missing_legacy_runtime_trace_hash")
+    elif not is_sha256(legacy_hash):
+        reasons.append("legacy_runtime_trace_hash_not_sha256")
+    if not is_sha256(record.get("modern_observation_hash")):
+        reasons.append("modern_observation_hash_not_sha256")
+    return not reasons, reasons
+
+
+def load_live_trace_matches(trace_dir: Path | None, required_ids: set[str]) -> dict[str, Any]:
+    if trace_dir is None:
+        return {
+            "trace_dir": None,
+            "trace_dir_exists": False,
+            "accepted_matches": {},
+            "rejected_records": [],
+            "files_scanned": [],
+        }
+
+    trace_dir = trace_dir.resolve()
+    files = sorted(trace_dir.rglob("*.json")) if trace_dir.exists() else []
+    accepted: dict[str, dict[str, Any]] = {}
+    rejected: list[dict[str, Any]] = []
+    for path in files:
+        try:
+            payload = read_json(path)
+        except Exception as exc:
+            rejected.append({"path": str(path), "reasons": [f"json_parse_error:{exc}"]})
+            continue
+        for record in trace_candidates(payload):
+            ok, reasons = validate_trace_record(record, required_ids)
+            capability_id = record.get("capability_id")
+            if ok and isinstance(capability_id, str):
+                accepted[capability_id] = {
+                    "path": str(path),
+                    "trace_kind": record["trace_kind"],
+                    "legacy_runtime_environment": record["legacy_runtime_environment"],
+                    "raw_legacy_trace_hash": next(record.get(field) for field in TRACE_HASH_FIELDS if record.get(field)),
+                    "modern_observation_hash": record["modern_observation_hash"],
+                    "comparator_version": record["comparator_version"],
+                }
+            else:
+                rejected.append(
+                    {
+                        "path": str(path),
+                        "capability_id": capability_id,
+                        "reasons": reasons,
+                    }
+                )
+    return {
+        "trace_dir": str(trace_dir),
+        "trace_dir_exists": trace_dir.exists(),
+        "accepted_matches": accepted,
+        "rejected_records": rejected,
+        "files_scanned": [str(path) for path in files],
+    }
+
+
+def build_a_grade_report(modern_root: Path, source_root: Path, trace_dir: Path | None = None) -> dict[str, Any]:
+    modern_root = modern_root.resolve()
+    source_root = source_root.resolve()
+    ledger = load_capability_ledger(modern_root)
+    current_parity = load_current_parity(modern_root)
+    required_ids = {item["capability_id"] for item in ledger}
+    trace_status = load_live_trace_matches(trace_dir, required_ids)
+    accepted_matches = trace_status["accepted_matches"]
+    missing_ids = sorted(required_ids - set(accepted_matches))
+    runtime_assets = inspect_runtime_assets(source_root)
+    tool_probe = {name: command_probe(name) for name in RUNTIME_TOOL_PROBES}
+
+    blockers = []
+    if missing_ids:
+        blockers.append(
+            {
+                "code": "missing_live_legacy_trace_corpus",
+                "detail": (
+                    f"A-grade requires accepted live legacy runtime matches for all {len(required_ids)} "
+                    f"capabilities; accepted={len(accepted_matches)}, missing={len(missing_ids)}."
+                ),
+            }
+        )
+    if not any(asset.get("exists") for asset in runtime_assets):
+        blockers.append(
+            {
+                "code": "missing_legacy_runtime_assets",
+                "detail": "No AWS M2 runtime zip assets were found under the pinned source tree.",
+            }
+        )
+    else:
+        blockers.append(
+            {
+                "code": "runtime_assets_not_execution_evidence",
+                "detail": (
+                    "AWS M2/Micro Focus/UniKix package artifacts were found, but this run did not execute "
+                    "them to produce COBOL/CICS transaction traces."
+                ),
+            }
+        )
+    if not tool_probe["aws"]["present"] and not tool_probe["hercules"]["present"]:
+        blockers.append(
+            {
+                "code": "no_local_mainframe_or_aws_runtime_path_detected",
+                "detail": "Neither AWS CLI nor a local mainframe emulator was detected for a runtime capture path.",
+            }
+        )
+    blockers.append(
+        {
+            "code": "static_oracle_is_not_a_grade",
+            "detail": "The current B=50 proof is strong static/source-oracle evidence, but A requires live runtime traces.",
+        }
+    )
+
+    promotable = not missing_ids
+    current_grade_counts = dict(current_parity["grade_counts"])
+    proposed_grade_counts = dict(current_grade_counts)
+    if promotable:
+        proposed_grade_counts.update({"A": len(required_ids), "B": 0, "F": 0})
+
+    capability_status = []
+    ledger_by_id = {item["capability_id"]: item for item in ledger}
+    for capability_id in sorted(required_ids):
+        ledger_item = ledger_by_id[capability_id]
+        capability_status.append(
+            {
+                "capability_id": capability_id,
+                "surface": ledger_item.get("surface"),
+                "transaction": ledger_item.get("transaction"),
+                "program": ledger_item.get("program"),
+                "function": ledger_item.get("function"),
+                "current_proof_grade": ledger_item.get("proof_grade"),
+                "a_grade_match_found": capability_id in accepted_matches,
+                "accepted_trace": accepted_matches.get(capability_id),
+                "missing_reason": None if capability_id in accepted_matches else "no_accepted_live_legacy_runtime_trace",
+            }
+        )
+
+    report: dict[str, Any] = {
+        "report_version": REPORT_VERSION,
+        "generated_utc": datetime.now(timezone.utc).replace(microsecond=0).isoformat(),
+        "source": {
+            "repo_url": SOURCE_REMOTE,
+            "head": SOURCE_HEAD,
+            "local_path": str(source_root),
+        },
+        "modern_code": {
+            "local_path": str(modern_root),
+        },
+        "requested_target": {
+            "grade": "A",
+            "scope": "all capabilities",
+            "capability_count": len(required_ids),
+        },
+        "rubric": {
+            "A": "actual legacy COBOL/CICS runtime trace matched to modern observed behavior for the capability",
+            "B": "static legacy data/copybook/source-oracle match plus executable modern-service replay",
+            "F": "known parity gap or missing capability under the current rubric",
+        },
+        "current_static_source_oracle_status": {
+            "capability_count": current_parity["capability_count"],
+            "grade_counts": current_grade_counts,
+            "gap_count": current_parity["gap_count"],
+            "static_oracle_or_better_count": current_parity["static_oracle_or_better_count"],
+            "strict_runtime_parity_count": current_parity["strict_runtime_parity_count"],
+            "receipt_hash": current_parity["receipt_hash"],
+            "receipt_generated_utc": current_parity["receipt_generated_utc"],
+        },
+        "a_grade_gate": {
+            "promotable_to_A": promotable,
+            "required_live_matches": len(required_ids),
+            "accepted_live_matches": len(accepted_matches),
+            "missing_live_matches": len(missing_ids),
+            "current_A": current_grade_counts.get("A", 0),
+            "target_A": len(required_ids),
+            "proposed_grade_counts_if_gate_passes": proposed_grade_counts,
+            "missing_capability_ids": missing_ids,
+        },
+        "legacy_runtime_trace_contract": {
+            "accepted_trace_kinds": sorted(ACCEPTED_TRACE_KINDS),
+            "required_fields": list(REQUIRED_TRACE_FIELDS) + ["matched", "raw_legacy_trace_hash or legacy_runtime_trace_hash"],
+            "field_rules": {
+                "source_head": SOURCE_HEAD,
+                "matched": True,
+                "hash_fields": "64-character SHA-256 hex digests",
+                "capability_id": "must match one ID in reports/capability_ledger.json",
+            },
+        },
+        "legacy_runtime_environment_assessment": {
+            "source_prerequisites": [
+                "mainframe environment with CICS, VSAM, and JCL support",
+                "optional DB2, IMS DB, and MQ paths for optional modules",
+            ],
+            "local_execution_path_found": False,
+            "local_execution_path_reason": (
+                "No runnable COBOL/CICS/VSAM/JCL runtime was executed in this workspace. "
+                "Static replay and modern API tests are not live legacy execution."
+            ),
+            "tooling_probe": tool_probe,
+            "runtime_assets": runtime_assets,
+        },
+        "live_trace_scan": trace_status,
+        "capability_match_status": capability_status,
+        "blockers": blockers if not promotable else [],
+        "decision": {
+            "action": "promote_to_A" if promotable else "do_not_promote",
+            "why": (
+                "All required live runtime trace matches were accepted."
+                if promotable
+                else "The current bundle proves B=50/F=0/gaps=0 under the static/source-oracle rubric, "
+                "but it does not contain accepted live COBOL/CICS runtime traces for all capabilities."
+            ),
+            "next_non_human_path": [
+                "Run the pinned AWS CardDemo source in an AWS M2/mainframe-compatible runtime.",
+                "Capture transaction and batch outputs for each capability ID in reports/capability_ledger.json.",
+                "Replay the same inputs through the modern Python/SQLite service.",
+                "Emit JSON trace records satisfying legacy_runtime_trace_contract.",
+                "Rerun this gate with --legacy-trace-dir pointing at that corpus.",
+            ],
+        },
+        "public_actions_allowed": False,
+    }
+    report["report_hash"] = stable_hash(report)
+    return report
+
+
+def promotion_readme(report: dict[str, Any]) -> str:
+    gate = report["a_grade_gate"]
+    parity = report["current_static_source_oracle_status"]
+    return f"""
+# AWS CardDemo A-Grade Promotion Gate
+
+Report version: `{README_VERSION}`
+
+This file records the attempt to promote the AWS CardDemo modernization proof from B-grade static/source-oracle parity to A-grade live runtime parity.
+
+## Decision
+
+- Action: `{report['decision']['action']}`
+- Promotable to A: `{gate['promotable_to_A']}`
+- Current grade counts: `{parity['grade_counts']}`
+- Required live legacy runtime matches: `{gate['required_live_matches']}`
+- Accepted live legacy runtime matches: `{gate['accepted_live_matches']}`
+- Missing live legacy runtime matches: `{gate['missing_live_matches']}`
+- Current static/source-oracle status: B=`{parity['grade_counts'].get('B', 0)}`, F=`{parity['grade_counts'].get('F', 0)}`, gaps=`{parity['gap_count']}`
+
+## Rubric Boundary
+
+A-grade is reserved for actual legacy COBOL/CICS runtime traces matched against modern observed behavior for each capability. The existing proof remains B=50/F=0/gaps=0 under the current static/source-oracle rubric.
+
+This is not live COBOL/CICS all-path runtime equivalence.
+
+## Replay Command
+
+```powershell
+python tools\\evaluate_a_grade_promotion.py --source-root ..\\source --out-dir .\\final_proof
+```
+
+To test a future live trace corpus, add:
+
+```powershell
+--legacy-trace-dir <path-to-live-trace-json-corpus>
+```
+
+## Required Trace Contract
+
+Each accepted live trace record must include the fields listed in `A_GRADE_PROMOTION_REPORT.json` under `legacy_runtime_trace_contract`. The key requirements are: pinned source head, live trace kind, matched=true, a capability ID from the ledger, and SHA-256 hashes for the raw legacy trace and modern observation.
+"""
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Evaluate whether CardDemo proof can be promoted to A-grade parity")
+    parser.add_argument("--modern-root", type=Path, default=Path(__file__).resolve().parents[1])
+    parser.add_argument("--source-root", type=Path, default=Path(__file__).resolve().parents[2] / "source")
+    parser.add_argument("--out-dir", type=Path, default=None)
+    parser.add_argument("--legacy-trace-dir", type=Path, default=None)
+    parser.add_argument("--fail-if-not-promotable", action="store_true")
+    args = parser.parse_args()
+
+    modern_root = args.modern_root.resolve()
+    source_root = args.source_root.resolve()
+    out_dir = (args.out_dir or modern_root / "final_proof").resolve()
+    trace_dir = args.legacy_trace_dir.resolve() if args.legacy_trace_dir else None
+
+    report = build_a_grade_report(modern_root, source_root, trace_dir)
+    write_json(out_dir / "A_GRADE_PROMOTION_REPORT.json", report)
+    write_text(out_dir / "A_GRADE_PROMOTION_README.md", promotion_readme(report))
+
+    print(
+        json.dumps(
+            {
+                "out_dir": str(out_dir),
+                "promotable_to_A": report["a_grade_gate"]["promotable_to_A"],
+                "current_grade_counts": report["current_static_source_oracle_status"]["grade_counts"],
+                "required_live_matches": report["a_grade_gate"]["required_live_matches"],
+                "accepted_live_matches": report["a_grade_gate"]["accepted_live_matches"],
+                "missing_live_matches": report["a_grade_gate"]["missing_live_matches"],
+                "report_hash": report["report_hash"],
+            },
+            indent=2,
+            sort_keys=True,
+        )
+    )
+    if args.fail_if_not_promotable and not report["a_grade_gate"]["promotable_to_A"]:
+        raise SystemExit(2)
+
+
+if __name__ == "__main__":
+    main()

modern_code/tools/generate_receipts.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from carddemo.parity import build_parity_evidence
+from carddemo.repository import seed_from_legacy
+from carddemo.service import CardDemoService
+
+
+def sha256_path(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def collect_hashes(root: Path, patterns: tuple[str, ...]) -> dict[str, str]:
+    hashes: dict[str, str] = {}
+    for pattern in patterns:
+        for path in root.rglob(pattern):
+            if path.is_file():
+                hashes[str(path.relative_to(root)).replace("\\", "/")] = sha256_path(path)
+    return dict(sorted(hashes.items()))
+
+
+def write_json(path: Path, payload: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--source-root", type=Path, required=True)
+    parser.add_argument("--db-path", type=Path, required=True)
+    parser.add_argument("--out-dir", type=Path, required=True)
+    args = parser.parse_args()
+
+    counts = seed_from_legacy(args.source_root, args.db_path, reset=True)
+    service = CardDemoService(args.db_path)
+    summary = service.summary()
+    source_hashes = collect_hashes(
+        args.source_root,
+        ("*.cbl", "*.CBL", "*.cpy", "*.CPY", "*.bms", "*.jcl", "*.JCL", "*.txt", "*.PS"),
+    )
+    modern_root = Path(__file__).resolve().parents[1]
+    modern_hashes = collect_hashes(modern_root, ("*.py", "*.html", "*.css", "*.js", "*.md"))
+    source_head = "59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e"
+    capability_evidence = build_parity_evidence(args.source_root, args.db_path, source_head=source_head)
+
+    receipt = {
+        "receipt_version": "modern_carddemo_receipt_v0",
+        "generated_utc": datetime.now(timezone.utc).replace(microsecond=0).isoformat(),
+        "source_root": str(args.source_root.resolve()),
+        "source_head": source_head,
+        "modern_root": str(modern_root.resolve()),
+        "seed_counts": counts,
+        "summary": summary,
+        "source_hash_count": len(source_hashes),
+        "modern_hash_count": len(modern_hashes),
+        "source_hashes": source_hashes,
+        "modern_hashes": modern_hashes,
+        "supported_capabilities": [
+            "customer_search",
+            "account_view",
+            "account_update",
+            "card_list",
+            "card_view",
+            "card_update",
+            "transaction_list",
+            "transaction_add",
+            "bill_payment",
+            "post_transaction",
+            "signon",
+            "main_menu",
+            "admin_menu",
+            "user_add",
+            "user_update",
+            "user_delete",
+            "transaction_type_and_category_lookup",
+            "transaction_type_maintenance",
+            "transaction_report",
+            "account_statement",
+            "interest_projection",
+            "combined_transaction_preview",
+            "disclosure_group_seed_load",
+            "transaction_category_balance_seed_load",
+            "user_security_decode",
+            "browser_ui",
+            "json_api",
+        ],
+        "gap_capabilities": [
+            f"{row['capability_id']}: {row['function']} ({row['current_grade']})"
+            for row in capability_evidence["next_gap_ranking"][:20]
+        ],
+        "capability_parity": capability_evidence["summary"],
+        "proof_grade_meanings": capability_evidence["proof_grade_meanings"],
+        "claim_limit": "capability ledger and static-oracle traces only; no all-path COBOL runtime proof yet",
+        "public_actions_allowed": False,
+    }
+    receipt["receipt_hash"] = hashlib.sha256(
+        json.dumps(receipt, sort_keys=True, default=str).encode("utf-8")
+    ).hexdigest()
+    write_json(args.out_dir / "modernization_receipt.json", receipt)
+
+    parity = {
+        "parity_report_version": "modern_carddemo_parity_gap_v0",
+        "generated_utc": receipt["generated_utc"],
+        "checks": [
+            {"check": "customer_seed_count", "expected": 50, "actual": counts["customers"], "passed": counts["customers"] == 50},
+            {"check": "account_seed_count", "expected": 50, "actual": counts["accounts"], "passed": counts["accounts"] == 50},
+            {"check": "card_seed_count", "expected": 50, "actual": counts["cards"], "passed": counts["cards"] == 50},
+            {"check": "transaction_seed_count", "expected": 300, "actual": counts["transactions"], "passed": counts["transactions"] == 300},
+            {"check": "user_seed_count", "expected": 10, "actual": counts["users"], "passed": counts["users"] == 10},
+            {"check": "source_hashes_recorded", "expected": ">0", "actual": len(source_hashes), "passed": bool(source_hashes)},
+            {"check": "modern_hashes_recorded", "expected": ">0", "actual": len(modern_hashes), "passed": bool(modern_hashes)},
+            {
+                "check": "capability_ledger_materialized",
+                "expected": 50,
+                "actual": capability_evidence["summary"]["capability_count"],
+                "passed": capability_evidence["summary"]["capability_count"] == 50,
+            },
+            {
+                "check": "golden_traces_materialized",
+                "expected": ">0",
+                "actual": capability_evidence["summary"]["golden_trace_count"],
+                "passed": capability_evidence["summary"]["golden_trace_count"] > 0,
+            },
+            {
+                "check": "edge_cases_mined",
+                "expected": ">0",
+                "actual": capability_evidence["summary"]["edge_case_count"],
+                "passed": capability_evidence["summary"]["edge_case_count"] > 0,
+            },
+        ],
+        "unresolved_gaps": receipt["gap_capabilities"],
+        "capability_parity": capability_evidence["summary"],
+        "proof_grade_meanings": capability_evidence["proof_grade_meanings"],
+        "one_for_one_parity_ready": capability_evidence["summary"]["one_for_one_parity_ready"],
+        "public_actions_allowed": False,
+    }
+    parity["passed"] = all(row["passed"] for row in parity["checks"])
+    parity["parity_hash"] = hashlib.sha256(json.dumps(parity, sort_keys=True).encode("utf-8")).hexdigest()
+    write_json(args.out_dir / "capability_ledger.json", capability_evidence["capability_ledger"])
+    write_json(args.out_dir / "golden_traces.json", capability_evidence["golden_traces"])
+    write_json(args.out_dir / "edge_cases.json", capability_evidence["edge_cases"])
+    write_json(args.out_dir / "next_gap_ranking.json", capability_evidence["next_gap_ranking"])
+    write_json(args.out_dir / "parity_gap_report.json", parity)
+    print(json.dumps({"receipt": str(args.out_dir / "modernization_receipt.json"), "parity": str(args.out_dir / "parity_gap_report.json"), "passed": parity["passed"]}, indent=2))
+
+
+if __name__ == "__main__":
+    main()

modern_code/tools/package_final_proof.py

@@ -0,0 +1,619 @@
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import shutil
+import subprocess
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+SOURCE_REMOTE = "https://github.com/aws-samples/aws-mainframe-modernization-carddemo.git"
+SOURCE_HEAD = "59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e"
+CLAIM_LIMIT = (
+    "This proof is static/source-oracle parity plus executable modern-service replay. "
+    "It is not live COBOL/CICS all-path runtime equivalence."
+)
+OUTPUT_FILES = [
+    "FINAL_PROOF_README.md",
+    "FINAL_RECEIPT_SUMMARY.json",
+    "REPRO_COMMANDS.txt",
+    "STATIC_ORACLE_REPLAY_REPORT.json",
+    "KNOWN_LIMITS.md",
+    "ARTIFACT_MANIFEST.json",
+]
+OPTIONAL_OUTPUT_FILES = [
+    "A_GRADE_PROMOTION_REPORT.json",
+    "A_GRADE_PROMOTION_README.md",
+    "NO_COST_CONFIDENCE_REPORT.json",
+    "NO_COST_CONFIDENCE_README.md",
+]
+
+
+def read_json(path: Path) -> Any:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def write_json(path: Path, payload: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2, sort_keys=True, default=str) + "\n", encoding="utf-8")
+
+
+def write_text(path: Path, text: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text.rstrip() + "\n", encoding="utf-8")
+
+
+def sha256_path(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def stable_hash(payload: Any) -> str:
+    return hashlib.sha256(json.dumps(payload, sort_keys=True, default=str).encode("utf-8")).hexdigest()
+
+
+def file_record(path: Path, *, base: Path | None = None, role: str = "artifact") -> dict[str, Any]:
+    label = str(path.resolve())
+    if base is not None:
+        try:
+            label = str(path.resolve().relative_to(base.resolve()))
+        except ValueError:
+            label = str(path.resolve())
+    return {
+        "path": label.replace("\\", "/"),
+        "absolute_path": str(path.resolve()),
+        "role": role,
+        "exists": path.exists(),
+        "size_bytes": path.stat().st_size if path.exists() else None,
+        "sha256": sha256_path(path) if path.exists() and path.is_file() else None,
+    }
+
+
+def git_value(source_root: Path, *args: str) -> str:
+    safe_dir = source_root.resolve().as_posix()
+    result = subprocess.run(
+        ["git", "-c", f"safe.directory={safe_dir}", "-C", str(source_root), *args],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    return result.stdout.strip() if result.returncode == 0 else ""
+
+
+def git_identity(source_root: Path) -> dict[str, Any]:
+    return {
+        "remote_url": git_value(source_root, "remote", "get-url", "origin") or SOURCE_REMOTE,
+        "head": git_value(source_root, "rev-parse", "HEAD") or SOURCE_HEAD,
+        "status_short": git_value(source_root, "status", "--short"),
+    }
+
+
+def command_lines(source_head: str) -> dict[str, str]:
+    return {
+        "setup": r"python -m carddemo.cli init-db --source-root ..\source --db-path .\carddemo.sqlite",
+        "run": r"python -m carddemo.cli serve --source-root ..\source --db-path .\carddemo.sqlite --port 8087",
+        "test": r"python -m unittest discover -s tests",
+        "receipt": r"python tools\generate_receipts.py --source-root ..\source --db-path .\carddemo.sqlite --out-dir .\reports",
+        "static_oracle_replay": rf"python tools\replay_static_oracles.py --source-root ..\source --out-dir .\reports --source-head {source_head}",
+        "a_grade_promotion": r"python tools\evaluate_a_grade_promotion.py --source-root ..\source --out-dir .\final_proof",
+        "no_cost_confidence": r"python tools\build_no_cost_confidence.py --source-root ..\source --out-dir .\final_proof",
+        "package_final_proof": r"python tools\package_final_proof.py --source-root ..\source",
+        "all_local_proof_no_server": (
+            f'powershell -NoProfile -Command "python -m carddemo.cli init-db --source-root ..\\source '
+            f'--db-path .\\carddemo.sqlite; python -m unittest discover -s tests; '
+            f'python tools\\generate_receipts.py --source-root ..\\source --db-path .\\carddemo.sqlite '
+            f'--out-dir .\\reports; python tools\\replay_static_oracles.py --source-root ..\\source '
+            f'--out-dir .\\reports --source-head {source_head}; '
+            f'python tools\\evaluate_a_grade_promotion.py --source-root ..\\source --out-dir .\\final_proof; '
+            f'python tools\\build_no_cost_confidence.py --source-root ..\\source --out-dir .\\final_proof; '
+            f'python tools\\package_final_proof.py --source-root ..\\source"'
+        ),
+    }
+
+
+def validate_current_rubric(receipt: dict[str, Any], replay: dict[str, Any], next_gaps: list[Any]) -> None:
+    parity = receipt["capability_parity"]
+    grade_counts = parity["grade_counts"]
+    failures = []
+    if parity["capability_count"] != 50:
+        failures.append(f"capability_count={parity['capability_count']}")
+    if grade_counts.get("B") != 50:
+        failures.append(f"B={grade_counts.get('B')}")
+    if grade_counts.get("F") != 0:
+        failures.append(f"F={grade_counts.get('F')}")
+    if parity["gap_count"] != 0:
+        failures.append(f"gap_count={parity['gap_count']}")
+    if next_gaps:
+        failures.append("next_gap_ranking_not_empty")
+    if not replay.get("passed"):
+        failures.append("static_oracle_replay_failed")
+    if failures:
+        raise SystemExit("Cannot package final proof; rubric checks failed: " + ", ".join(failures))
+
+
+def load_verification(out_dir: Path) -> dict[str, Any] | None:
+    path = out_dir / "CLEAN_REPRO_VERIFICATION.json"
+    return read_json(path) if path.exists() else None
+
+
+def load_a_grade_report(out_dir: Path) -> dict[str, Any] | None:
+    path = out_dir / "A_GRADE_PROMOTION_REPORT.json"
+    return read_json(path) if path.exists() else None
+
+
+def load_no_cost_report(out_dir: Path) -> dict[str, Any] | None:
+    path = out_dir / "NO_COST_CONFIDENCE_REPORT.json"
+    return read_json(path) if path.exists() else None
+
+
+def summarize_a_grade_report(out_dir: Path, report: dict[str, Any] | None) -> dict[str, Any] | None:
+    if report is None:
+        return None
+    gate = report["a_grade_gate"]
+    parity = report["current_static_source_oracle_status"]
+    return {
+        "path": str((out_dir / "A_GRADE_PROMOTION_REPORT.json").resolve()),
+        "readme_path": str((out_dir / "A_GRADE_PROMOTION_README.md").resolve()),
+        "report_version": report["report_version"],
+        "report_hash": report["report_hash"],
+        "generated_utc": report["generated_utc"],
+        "decision_action": report["decision"]["action"],
+        "promotable_to_A": gate["promotable_to_A"],
+        "required_live_matches": gate["required_live_matches"],
+        "accepted_live_matches": gate["accepted_live_matches"],
+        "missing_live_matches": gate["missing_live_matches"],
+        "current_A": gate["current_A"],
+        "target_A": gate["target_A"],
+        "current_grade_counts": parity["grade_counts"],
+        "current_gap_count": parity["gap_count"],
+        "blocker_codes": [blocker["code"] for blocker in report.get("blockers", [])],
+        "trace_contract": report["legacy_runtime_trace_contract"],
+    }
+
+
+def summarize_no_cost_report(out_dir: Path, report: dict[str, Any] | None) -> dict[str, Any] | None:
+    if report is None:
+        return None
+    summary = report["no_cost_confidence_summary"]
+    coverage = report["capability_coverage"]
+    replay = report["static_oracle_replay"]
+    a_gate = report["a_grade_gate"]
+    return {
+        "path": str((out_dir / "NO_COST_CONFIDENCE_REPORT.json").resolve()),
+        "readme_path": str((out_dir / "NO_COST_CONFIDENCE_README.md").resolve()),
+        "report_version": report["report_version"],
+        "report_hash": report["report_hash"],
+        "generated_utc": report["generated_utc"],
+        "reviewer_posture": summary["reviewer_posture"],
+        "ready_for_pre_runtime_review": summary["ready_for_pre_runtime_review"],
+        "remaining_gap": summary["remaining_gap"],
+        "capability_count": coverage["capability_count"],
+        "static_oracle_ready_count": coverage["static_oracle_ready_count"],
+        "source_ref_total": coverage["source_ref_total"],
+        "static_replay_passed": replay["passed"],
+        "edge_case_count": report["fixture_corpus"]["edge_case_count"],
+        "golden_trace_count": report["fixture_corpus"]["golden_trace_count"],
+        "paid_runtime_used": report["no_cost_scope"]["paid_runtime_used"],
+        "legacy_runtime_claim_made": report["no_cost_scope"]["legacy_runtime_claim_made"],
+        "a_promotable": a_gate["promotable_to_A"],
+        "a_missing_live_matches": a_gate["missing_live_matches"],
+    }
+
+
+def build_summary(
+    modern_root: Path,
+    source_root: Path,
+    out_dir: Path,
+    receipt: dict[str, Any],
+    parity_report: dict[str, Any],
+    replay: dict[str, Any],
+    next_gaps: list[Any],
+    verification: dict[str, Any] | None,
+    a_grade_report: dict[str, Any] | None,
+    no_cost_report: dict[str, Any] | None,
+) -> dict[str, Any]:
+    source_git = git_identity(source_root)
+    commands = command_lines(source_git["head"])
+    screenshot = modern_root / "reports" / "ui_batch_reports_smoke.png"
+    smoke_evidence = []
+    if screenshot.exists():
+        smoke_evidence.append(file_record(screenshot, base=modern_root, role="existing_screenshot"))
+    if verification and verification.get("api_smoke"):
+        smoke_evidence.append(
+            {
+                "role": "clean_copy_api_smoke",
+                "passed": verification.get("api_smoke_passed"),
+                "port": verification.get("server_port"),
+                "endpoints": list(verification["api_smoke"].keys()),
+            }
+        )
+
+    parity = receipt["capability_parity"]
+    return {
+        "summary_version": "carddemo_final_proof_summary_v0",
+        "generated_utc": datetime.now(timezone.utc).replace(microsecond=0).isoformat(),
+        "source": {
+            "repo_url": source_git["remote_url"],
+            "head": source_git["head"],
+            "local_path": str(source_root.resolve()),
+            "status_short": source_git["status_short"],
+            "source_hash_count": receipt["source_hash_count"],
+            "source_hashes_digest": stable_hash(receipt["source_hashes"]),
+        },
+        "modern_code": {
+            "local_path": str(modern_root.resolve()),
+            "modern_hash_count": receipt["modern_hash_count"],
+            "modern_hashes_digest": stable_hash(receipt["modern_hashes"]),
+        },
+        "commands": commands,
+        "receipt": {
+            "path": str((modern_root / "reports" / "modernization_receipt.json").resolve()),
+            "receipt_hash": receipt["receipt_hash"],
+            "generated_utc": receipt["generated_utc"],
+            "seed_counts": receipt["seed_counts"],
+            "source_head": receipt["source_head"],
+        },
+        "parity": {
+            "rubric": "current static/source-oracle rubric",
+            "capability_count": parity["capability_count"],
+            "grade_counts": parity["grade_counts"],
+            "B": parity["grade_counts"].get("B", 0),
+            "F": parity["grade_counts"].get("F", 0),
+            "gap_count": parity["gap_count"],
+            "next_gap_ranking_count": len(next_gaps),
+            "one_for_one_parity_ready": parity["one_for_one_parity_ready"],
+            "static_oracle_or_better_count": parity["static_oracle_or_better_count"],
+            "strict_runtime_parity_count": parity["strict_runtime_parity_count"],
+            "proof_grade_meanings": receipt["proof_grade_meanings"],
+            "parity_report_passed": parity_report["passed"],
+            "parity_hash": parity_report["parity_hash"],
+        },
+        "static_oracle_replay": {
+            "path": str((out_dir / "STATIC_ORACLE_REPLAY_REPORT.json").resolve()),
+            "source_report_path": str((modern_root / "reports" / "static_oracle_replay.json").resolve()),
+            "passed": replay["passed"],
+            "replay_hash": replay["replay_hash"],
+            "evidence_hash": replay["evidence_hash"],
+            "runtime_probe_count": replay["runtime_probe_count"],
+            "failed_checks": replay["failed_checks"],
+            "claim_limit": replay["claim_limit"],
+        },
+        "smoke_evidence": smoke_evidence,
+        "clean_repro_verification": verification,
+        "a_grade_promotion": summarize_a_grade_report(out_dir, a_grade_report),
+        "no_cost_confidence": summarize_no_cost_report(out_dir, no_cost_report),
+        "known_limits": [
+            CLAIM_LIMIT,
+            "A-grade live legacy runtime trace matching remains 0 under the current proof-grade rubric.",
+            "A-grade promotion is gated by A_GRADE_PROMOTION_REPORT.json and requires accepted live legacy runtime traces.",
+            "NO_COST_CONFIDENCE_REPORT.json records maximum unpaid/pre-runtime evidence and the remaining paid/runtime validation boundary.",
+            "The static replay exercises selected trace expectations; it is not exhaustive path coverage.",
+            "The modern app is a local Python/SQLite target and not a production deployment package.",
+        ],
+        "public_actions_allowed": False,
+        "bundle_path": str(out_dir.resolve()),
+    }
+
+
+def final_readme(summary: dict[str, Any]) -> str:
+    commands = summary["commands"]
+    verification = summary.get("clean_repro_verification") or {}
+    a_grade = summary.get("a_grade_promotion")
+    no_cost = summary.get("no_cost_confidence")
+    clean_status = "not run"
+    if verification:
+        clean_status = "passed" if verification.get("passed") else "failed"
+    smoke_lines = []
+    for item in summary["smoke_evidence"]:
+        if item["role"] == "existing_screenshot":
+            smoke_lines.append(f"- Screenshot: `{item['path']}` SHA-256 `{item['sha256']}`.")
+        elif item["role"] == "clean_copy_api_smoke":
+            smoke_lines.append(
+                f"- Clean-copy API smoke: passed={item['passed']} port={item['port']} endpoints={', '.join(item['endpoints'])}."
+            )
+    if not smoke_lines:
+        smoke_lines.append("- No screenshot or API smoke artifact is bundled.")
+    if a_grade:
+        a_grade_lines = [
+            f"- A-grade gate decision: `{a_grade['decision_action']}`",
+            f"- Promotable to A: `{a_grade['promotable_to_A']}`",
+            f"- Required live legacy runtime matches: `{a_grade['required_live_matches']}`",
+            f"- Accepted live legacy runtime matches: `{a_grade['accepted_live_matches']}`",
+            f"- Missing live legacy runtime matches: `{a_grade['missing_live_matches']}`",
+            f"- A-grade report hash: `{a_grade['report_hash']}`",
+        ]
+    else:
+        a_grade_lines = ["- A-grade promotion gate was not run before packaging."]
+    if no_cost:
+        no_cost_lines = [
+            f"- Reviewer posture: `{no_cost['reviewer_posture']}`",
+            f"- Ready for pre-runtime review: `{no_cost['ready_for_pre_runtime_review']}`",
+            f"- Paid runtime used: `{no_cost['paid_runtime_used']}`",
+            f"- Legacy runtime claim made: `{no_cost['legacy_runtime_claim_made']}`",
+            f"- Source-backed static capabilities: `{no_cost['static_oracle_ready_count']}`",
+            f"- Source refs in capability ledger: `{no_cost['source_ref_total']}`",
+            f"- Golden traces / edge cases: `{no_cost['golden_trace_count']}` / `{no_cost['edge_case_count']}`",
+            f"- Remaining gap: `{no_cost['remaining_gap']}`",
+            f"- No-cost confidence report hash: `{no_cost['report_hash']}`",
+        ]
+    else:
+        no_cost_lines = ["- No-cost confidence proof was not run before packaging."]
+
+    return f"""
+# AWS CardDemo Modernization Final Proof
+
+This bundle packages the local AWS CardDemo modernization run as a reproducible technical-review artifact. It does not add application features; it records the source identity, modern code location, commands, receipts, static-oracle replay, no-cost confidence proof, A-grade promotion gate, known limits, and clean-copy verification status.
+
+## Source Identity
+
+- Source repo: `{summary['source']['repo_url']}`
+- Source version: `{summary['source']['head']}`
+- Source local path used for this run: `{summary['source']['local_path']}`
+- Source file hash count in receipt: `{summary['source']['source_hash_count']}`
+- Source hash digest over receipt map: `{summary['source']['source_hashes_digest']}`
+
+## Modern Code
+
+- Modern code path: `{summary['modern_code']['local_path']}`
+- Modern file hash count in receipt: `{summary['modern_code']['modern_hash_count']}`
+- Modern hash digest over receipt map: `{summary['modern_code']['modern_hashes_digest']}`
+
+## One-Command Setup And Run
+
+Run these from the modern code root with the AWS CardDemo source clone/copy at `..\\source`.
+
+Setup database:
+
+```powershell
+{commands['setup']}
+```
+
+Run web/API server:
+
+```powershell
+{commands['run']}
+```
+
+Open `http://127.0.0.1:8087`.
+
+## One-Command Tests
+
+```powershell
+{commands['test']}
+```
+
+## One-Command Static-Oracle Replay
+
+```powershell
+{commands['static_oracle_replay']}
+```
+
+## One-Command A-Grade Promotion Gate
+
+```powershell
+{commands['a_grade_promotion']}
+```
+
+## One-Command No-Cost Confidence Proof
+
+```powershell
+{commands['no_cost_confidence']}
+```
+
+## Full Local Proof Refresh
+
+```powershell
+{commands['all_local_proof_no_server']}
+```
+
+## Final Receipt Summary
+
+- Receipt hash: `{summary['receipt']['receipt_hash']}`
+- Receipt generated: `{summary['receipt']['generated_utc']}`
+- Static replay hash: `{summary['static_oracle_replay']['replay_hash']}`
+- Static replay passed: `{summary['static_oracle_replay']['passed']}`
+- Runtime probe count: `{summary['static_oracle_replay']['runtime_probe_count']}`
+- Failed replay checks: `{summary['static_oracle_replay']['failed_checks']}`
+
+## Parity Summary
+
+Under the current static/source-oracle rubric:
+
+- Capability count: `{summary['parity']['capability_count']}`
+- B-grade static/source-oracle capabilities: `{summary['parity']['B']}`
+- F-grade gaps: `{summary['parity']['F']}`
+- Gap count: `{summary['parity']['gap_count']}`
+- Next-gap ranking count: `{summary['parity']['next_gap_ranking_count']}`
+- Static-oracle-or-better count: `{summary['parity']['static_oracle_or_better_count']}`
+- A-grade live legacy runtime trace count: `{summary['parity']['strict_runtime_parity_count']}`
+
+Proof grade meanings are recorded in `FINAL_RECEIPT_SUMMARY.json`.
+
+## No-Cost Confidence Proof
+
+{chr(10).join(no_cost_lines)}
+
+This is the maximum unpaid/pre-runtime evidence layer. It is meant to convince a technical reviewer that the modernization is probably functional under the extracted legacy-derived behavior, while preserving the live runtime validation gap.
+
+## A-Grade Promotion Gate
+
+{chr(10).join(a_grade_lines)}
+
+The A-grade gate is intentionally stricter than the B-grade static/source-oracle proof. It requires accepted live legacy COBOL/CICS runtime trace matches for each capability before any capability can be promoted to A.
+
+## Smoke Evidence
+
+{chr(10).join(smoke_lines)}
+
+## Clean-Copy Verification
+
+- Clean-copy verification status: `{clean_status}`
+- Verification report included in `FINAL_RECEIPT_SUMMARY.json` when present.
+
+## Caveat
+
+{CLAIM_LIMIT}
+
+See `KNOWN_LIMITS.md` for the full claim boundary.
+"""
+
+
+def known_limits() -> str:
+    return f"""
+# Known Limits
+
+{CLAIM_LIMIT}
+
+- Proof grade `B` means static legacy data/copybook/source-oracle match. It does not mean the original COBOL/CICS system was executed and compared for every path.
+- Proof grade `A` is reserved for actual legacy runtime trace match; this bundle records `A=0`.
+- `A_GRADE_PROMOTION_REPORT.json` is the executable promotion gate. It fails closed unless accepted live legacy runtime trace records exist for every capability.
+- `NO_COST_CONFIDENCE_REPORT.json` records maximum unpaid/pre-runtime evidence. It is designed to support review confidence, not to replace live legacy validation.
+- The replay report executes the modern Python service against extracted static/source-oracle expectations. It is useful evidence, but not exhaustive path coverage.
+- The source data and copybooks are from AWS CardDemo at the pinned source version in `FINAL_RECEIPT_SUMMARY.json`.
+- The app is a local Python/SQLite modernization target. Production concerns such as deployment topology, operations, security hardening, and load testing are outside this proof bundle.
+- Public release, upload, or promotion is intentionally not performed by this bundle.
+"""
+
+
+def repro_commands(summary: dict[str, Any]) -> str:
+    commands = summary["commands"]
+    return f"""
+Run from the modern code root. The source clone/copy must be at ..\\source.
+
+SOURCE REPO:
+{summary['source']['repo_url']}
+
+SOURCE HEAD:
+{summary['source']['head']}
+
+MODERN CODE:
+{summary['modern_code']['local_path']}
+
+SETUP:
+{commands['setup']}
+
+RUN SERVER:
+{commands['run']}
+
+TEST:
+{commands['test']}
+
+STATIC ORACLE REPLAY:
+{commands['static_oracle_replay']}
+
+A-GRADE PROMOTION GATE:
+{commands['a_grade_promotion']}
+
+NO-COST CONFIDENCE PROOF:
+{commands['no_cost_confidence']}
+
+REGENERATE RECEIPTS:
+{commands['receipt']}
+
+PACKAGE FINAL PROOF:
+{commands['package_final_proof']}
+
+FULL LOCAL PROOF REFRESH WITHOUT SERVER:
+{commands['all_local_proof_no_server']}
+
+CAVEAT:
+{CLAIM_LIMIT}
+"""
+
+
+def build_manifest(out_dir: Path, modern_root: Path) -> dict[str, Any]:
+    bundle_names = [name for name in OUTPUT_FILES if name != "ARTIFACT_MANIFEST.json"]
+    bundle_names.extend(name for name in OPTIONAL_OUTPUT_FILES if (out_dir / name).exists())
+    bundle_files = [file_record(out_dir / name, base=out_dir, role="final_bundle_output") for name in bundle_names]
+    existing = [
+        modern_root / "reports" / "modernization_receipt.json",
+        modern_root / "reports" / "parity_gap_report.json",
+        modern_root / "reports" / "capability_ledger.json",
+        modern_root / "reports" / "golden_traces.json",
+        modern_root / "reports" / "edge_cases.json",
+        modern_root / "reports" / "next_gap_ranking.json",
+        modern_root / "reports" / "static_oracle_replay.json",
+        modern_root / "reports" / "ui_batch_reports_smoke.png",
+    ]
+    verification = out_dir / "CLEAN_REPRO_VERIFICATION.json"
+    if verification.exists():
+        existing.append(verification)
+    payload = {
+        "manifest_version": "carddemo_final_proof_manifest_v0",
+        "generated_utc": datetime.now(timezone.utc).replace(microsecond=0).isoformat(),
+        "bundle_path": str(out_dir.resolve()),
+        "bundle_files": bundle_files,
+        "referenced_existing_artifacts": [file_record(path, base=modern_root, role="referenced_evidence") for path in existing if path.exists()],
+        "public_actions_allowed": False,
+    }
+    payload["manifest_payload_hash"] = stable_hash(payload)
+    return payload
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Package the final CardDemo proof bundle")
+    parser.add_argument("--modern-root", type=Path, default=Path(__file__).resolve().parents[1])
+    parser.add_argument("--source-root", type=Path, default=Path(__file__).resolve().parents[2] / "source")
+    parser.add_argument("--out-dir", type=Path, default=None)
+    args = parser.parse_args()
+
+    modern_root = args.modern_root.resolve()
+    source_root = args.source_root.resolve()
+    out_dir = (args.out_dir or modern_root / "final_proof").resolve()
+    reports = modern_root / "reports"
+
+    receipt = read_json(reports / "modernization_receipt.json")
+    parity_report = read_json(reports / "parity_gap_report.json")
+    replay = read_json(reports / "static_oracle_replay.json")
+    next_gaps = read_json(reports / "next_gap_ranking.json")
+    validate_current_rubric(receipt, replay, next_gaps)
+
+    out_dir.mkdir(parents=True, exist_ok=True)
+    verification = load_verification(out_dir)
+    a_grade_report = load_a_grade_report(out_dir)
+    no_cost_report = load_no_cost_report(out_dir)
+    summary = build_summary(
+        modern_root,
+        source_root,
+        out_dir,
+        receipt,
+        parity_report,
+        replay,
+        next_gaps,
+        verification,
+        a_grade_report,
+        no_cost_report,
+    )
+
+    shutil.copy2(reports / "static_oracle_replay.json", out_dir / "STATIC_ORACLE_REPLAY_REPORT.json")
+    write_json(out_dir / "FINAL_RECEIPT_SUMMARY.json", summary)
+    write_text(out_dir / "FINAL_PROOF_README.md", final_readme(summary))
+    write_text(out_dir / "REPRO_COMMANDS.txt", repro_commands(summary))
+    write_text(out_dir / "KNOWN_LIMITS.md", known_limits())
+    write_json(out_dir / "ARTIFACT_MANIFEST.json", build_manifest(out_dir, modern_root))
+
+    print(
+        json.dumps(
+            {
+                "out_dir": str(out_dir),
+                "files": OUTPUT_FILES,
+                "parity": summary["parity"],
+                "static_oracle_replay": summary["static_oracle_replay"],
+                "a_grade_promotion": summary["a_grade_promotion"],
+                "no_cost_confidence": summary["no_cost_confidence"],
+                "clean_repro_verification_present": verification is not None,
+            },
+            indent=2,
+            sort_keys=True,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

modern_code/tools/replay_static_oracles.py

@@ -0,0 +1,396 @@
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from carddemo.parity import build_parity_evidence
+from carddemo.repository import seed_from_legacy
+from carddemo.service import CardDemoService
+
+
+DEFAULT_SOURCE_HEAD = "59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e"
+CLAIM_LIMIT = (
+    "Executable modern replay over static/source-oracle traces only; "
+    "no live COBOL/CICS runtime replay has been performed."
+)
+
+EXPECTED_SEED_COUNTS = {
+    "customers": 50,
+    "accounts": 50,
+    "cards": 50,
+    "card_xrefs": 50,
+    "transactions": 300,
+    "transaction_types": 7,
+    "transaction_categories": 18,
+    "disclosure_groups": 51,
+    "transaction_category_balances": 50,
+    "users": 10,
+    "pending_authorization_summaries": 21,
+    "pending_authorization_details": 202,
+}
+
+REQUIRED_TRACE_IDS = {
+    "mq_system_date_cdrd_reply",
+    "mq_account_inquiry_cdra_success_and_invalid",
+    "batch_resource_setup_gdg_vsam_aix_cics",
+    "pending_authorization_cpvs_summary_page",
+    "pending_authorization_cp00_request_response_and_insert",
+    "transaction_type_lookup",
+}
+
+REQUIRED_EDGE_CASE_IDS = {
+    "mq_cdrd_request_payload_ignored",
+    "mq_cdra_inqa_account_key_validation",
+    "batch_gdg_limit_scratch_first_generation",
+    "vsam_esds_rrds_user_security_layout",
+    "transaction_aix_processed_timestamp_key",
+    "cics_file_control_command_set",
+    "pending_authorization_ims_segment_header_offset",
+    "authorization_available_credit_boundary",
+}
+
+
+def stable_json_hash(payload: Any) -> str:
+    return hashlib.sha256(json.dumps(payload, sort_keys=True, default=str).encode("utf-8")).hexdigest()
+
+
+def write_json(path: Path, payload: Any) -> Path:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2, sort_keys=True, default=str) + "\n", encoding="utf-8")
+    return path
+
+
+def add_check(
+    checks: list[dict[str, Any]],
+    name: str,
+    passed: bool,
+    *,
+    expected: Any = None,
+    actual: Any = None,
+    details: dict[str, Any] | None = None,
+) -> None:
+    row: dict[str, Any] = {"check": name, "passed": bool(passed)}
+    if expected is not None:
+        row["expected"] = expected
+    if actual is not None:
+        row["actual"] = actual
+    if details:
+        row["details"] = details
+    checks.append(row)
+
+
+def trace_expectations(evidence: dict[str, Any]) -> dict[str, dict[str, Any]]:
+    return {row["trace_id"]: row["expected"] for row in evidence["golden_traces"]}
+
+
+def add_runtime_probe(
+    checks: list[dict[str, Any]],
+    runtime_probes: list[dict[str, Any]],
+    trace_id: str,
+    actual: dict[str, Any],
+    expected_by_trace: dict[str, dict[str, Any]],
+) -> None:
+    expected = expected_by_trace.get(trace_id, {})
+    passed = bool(expected) and actual == expected
+    runtime_probes.append(
+        {
+            "trace_id": trace_id,
+            "passed": passed,
+            "expected": expected,
+            "actual": actual,
+        }
+    )
+    add_check(checks, f"{trace_id}_runtime_probe", passed, expected=expected, actual=actual)
+
+
+def build_runtime_probes(service: CardDemoService, expected_by_trace: dict[str, dict[str, Any]]) -> list[dict[str, Any]]:
+    checks: list[dict[str, Any]] = []
+    runtime_probes: list[dict[str, Any]] = []
+
+    mq_date = service.mq_system_date({"request_message": "IGNR00000000001"}, now="2026-05-23T11:12:13")
+    add_runtime_probe(
+        checks,
+        runtime_probes,
+        "mq_system_date_cdrd_reply",
+        {
+            "legacy_transaction": mq_date["legacy_transaction"],
+            "legacy_program": mq_date["legacy_program"],
+            "reply_queue": mq_date["reply_queue"],
+            "system_date": mq_date["system_date"],
+            "system_time": mq_date["system_time"],
+            "reply_message": mq_date["reply_message"],
+            "request_payload_validated": False,
+        },
+        expected_by_trace,
+    )
+
+    mq_account = service.mq_account_inquiry({"request_message": "INQA00000000001"})
+    mq_account_not_found = service.mq_account_inquiry({"function": "INQA", "account_id": 99999999999})
+    mq_account_bad_function = service.mq_account_inquiry({"function": "BAD", "account_id": 1})
+    add_runtime_probe(
+        checks,
+        runtime_probes,
+        "mq_account_inquiry_cdra_success_and_invalid",
+        {
+            "legacy_transaction": mq_account["legacy_transaction"],
+            "legacy_program": mq_account["legacy_program"],
+            "reply_queue": mq_account["reply_queue"],
+            "request_account_key": mq_account["request"]["account_id_text"],
+            "account_id": mq_account["account_data"]["account_id"],
+            "active_status": mq_account["account_data"]["active_status"],
+            "reply_has_account_label": "ACCOUNT ID : 00000000001" in mq_account["reply_message"],
+            "not_found_reply": mq_account_not_found["reply_message"],
+            "bad_function_reply": mq_account_bad_function["reply_message"],
+        },
+        expected_by_trace,
+    )
+
+    resource_setup = service.batch_resource_setup()
+    gdg_base_setup = service.batch_resource_setup("DEFGDGB")
+    db2_gdg_setup = service.batch_resource_setup("DEFGDGD")
+    esds_rrds_setup = service.batch_resource_setup("ESDSRRDS")
+    tranidx_setup = service.batch_resource_setup("TRANIDX")
+    closefil_setup = service.batch_resource_setup("CLOSEFIL")
+    openfil_setup = service.batch_resource_setup("OPENFIL")
+    add_runtime_probe(
+        checks,
+        runtime_probes,
+        "batch_resource_setup_gdg_vsam_aix_cics",
+        {
+            "resource_count": resource_setup["resource_count"],
+            "base_gdg_names": [row["name"] for row in gdg_base_setup["gdg_bases"]],
+            "db2_first_generation_counts": [
+                db2_gdg_setup["steps"][1]["record_count"],
+                db2_gdg_setup["steps"][3]["record_count"],
+                db2_gdg_setup["steps"][5]["record_count"],
+            ],
+            "esds_rrds_organizations": [row["organization"] for row in esds_rrds_setup["clusters"]],
+            "tranidx_keys": tranidx_setup["alternate_index"]["keys"],
+            "tranidx_source_count": tranidx_setup["bldindex"]["source_record_count"],
+            "close_code": closefil_setup["cemt_code"],
+            "open_code": openfil_setup["cemt_code"],
+            "file_sets_match": closefil_setup["files"] == openfil_setup["files"],
+        },
+        expected_by_trace,
+    )
+
+    pending_summary = service.pending_authorization_summary(1, page_size=5)
+    add_runtime_probe(
+        checks,
+        runtime_probes,
+        "pending_authorization_cpvs_summary_page",
+        {
+            "summary_count": pending_summary["summary"]["approved_auth_count"],
+            "summary_amount_cents": pending_summary["summary"]["approved_auth_amount_cents"],
+            "returned_authorizations": len(pending_summary["authorizations"]),
+            "next_page": pending_summary["next_page"],
+            "first_transaction_id": pending_summary["authorizations"][0]["transaction_id"],
+        },
+        expected_by_trace,
+    )
+
+    tx_types = service.transaction_types()
+    tx_types_filtered = service.transaction_types(type_filter="01")
+    tx_types_desc_filtered = service.transaction_types(description_filter="%PAYMENT%")
+    tx_types_backward = service.transaction_types(start_key="07", direction="backward", page_size=3)
+    add_runtime_probe(
+        checks,
+        runtime_probes,
+        "transaction_type_lookup",
+        {
+            "legacy_transaction": tx_types["legacy_transaction"],
+            "legacy_program": tx_types["legacy_program"],
+            "type_count": len(tx_types["types"]),
+            "category_count": len(tx_types["categories"]),
+            "page_size": tx_types["page"]["page_size"],
+            "type_filter_result": [row["type_code"] for row in tx_types_filtered["types"]],
+            "description_filter_count": len(tx_types_desc_filtered["types"]),
+            "backward_page_type_codes": [row["type_code"] for row in tx_types_backward["types"]],
+        },
+        expected_by_trace,
+    )
+
+    account_bundle = service.get_account_bundle(1) or {}
+    cards = account_bundle.get("cards", [])
+    card_number = cards[0]["card_number"] if cards else "9680294154603697"
+    cp00_before = service.pending_authorization_summary(1, page_size=1)
+    cp00 = service.process_authorization_request(
+        {
+            "card_number": card_number,
+            "auth_date": "260523",
+            "auth_time": "111213",
+            "card_expiry_date": "1129",
+            "transaction_amount_cents": 100,
+            "merchant_category_code": "5442",
+            "merchant_id": "123501000675423",
+            "merchant_name": "Amazon.com",
+            "merchant_city": "Wilmington",
+            "merchant_state": "DE",
+            "merchant_zip": "19801",
+            "transaction_id": "AUTHREQ00000001",
+            "processing_datetime": "2026-05-23T11:12:13.456",
+        }
+    )
+    cp00_after = service.pending_authorization_summary(1, page_size=1)
+    cp00_invalid = service.process_authorization_request(
+        {
+            "card_number": "9999999999999999",
+            "transaction_amount_cents": 100,
+            "transaction_id": "AUTHREQBAD0001",
+        }
+    )
+    add_runtime_probe(
+        checks,
+        runtime_probes,
+        "pending_authorization_cp00_request_response_and_insert",
+        {
+            "approved": cp00["approved"],
+            "response_code": cp00["response"]["auth_resp_code"],
+            "response_reason": cp00["response"]["auth_resp_reason"],
+            "written": cp00["written_to_pending_authorizations"],
+            "approved_count_delta": cp00_after["summary"]["approved_auth_count"]
+            - cp00_before["summary"]["approved_auth_count"],
+            "invalid_card_response_reason": cp00_invalid["response"]["auth_resp_reason"],
+            "invalid_card_written": cp00_invalid["written_to_pending_authorizations"],
+        },
+        expected_by_trace,
+    )
+
+    return checks + runtime_probes
+
+
+def build_static_oracle_replay(source_root: Path, db_path: Path, *, source_head: str = DEFAULT_SOURCE_HEAD) -> dict[str, Any]:
+    source_root = Path(source_root)
+    db_path = Path(db_path)
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+
+    seed_counts = seed_from_legacy(source_root, db_path, reset=True)
+    evidence = build_parity_evidence(source_root, db_path, source_head=source_head)
+    summary = evidence["summary"]
+    checks: list[dict[str, Any]] = []
+
+    actual_seed_counts = {key: seed_counts.get(key) for key in EXPECTED_SEED_COUNTS}
+    add_check(
+        checks,
+        "legacy_seed_count_contract",
+        actual_seed_counts == EXPECTED_SEED_COUNTS,
+        expected=EXPECTED_SEED_COUNTS,
+        actual=actual_seed_counts,
+    )
+    add_check(checks, "zero_capability_gaps", summary["gap_count"] == 0, expected=0, actual=summary["gap_count"])
+    add_check(checks, "empty_next_gap_ranking", evidence["next_gap_ranking"] == [], expected=[], actual=evidence["next_gap_ranking"])
+    add_check(
+        checks,
+        "all_capabilities_static_oracle_or_better",
+        summary["static_oracle_or_better_count"] == summary["capability_count"],
+        expected=summary["capability_count"],
+        actual=summary["static_oracle_or_better_count"],
+    )
+    add_check(
+        checks,
+        "no_partial_or_inferred_capabilities",
+        summary["partial_or_inferred_count"] == 0,
+        expected=0,
+        actual=summary["partial_or_inferred_count"],
+    )
+
+    trace_ids = {row["trace_id"] for row in evidence["golden_traces"]}
+    edge_case_ids = {row["edge_case_id"] for row in evidence["edge_cases"]}
+    missing_traces = sorted(REQUIRED_TRACE_IDS - trace_ids)
+    missing_edge_cases = sorted(REQUIRED_EDGE_CASE_IDS - edge_case_ids)
+    add_check(
+        checks,
+        "required_static_oracle_traces_present",
+        not missing_traces,
+        expected=sorted(REQUIRED_TRACE_IDS),
+        actual=sorted(trace_ids & REQUIRED_TRACE_IDS),
+        details={"missing": missing_traces},
+    )
+    add_check(
+        checks,
+        "required_edge_cases_present",
+        not missing_edge_cases,
+        expected=sorted(REQUIRED_EDGE_CASE_IDS),
+        actual=sorted(edge_case_ids & REQUIRED_EDGE_CASE_IDS),
+        details={"missing": missing_edge_cases},
+    )
+    add_check(
+        checks,
+        "all_golden_traces_static_oracle_or_better",
+        all(row["proof_grade"] in {"A", "B"} for row in evidence["golden_traces"]),
+        actual={row["trace_id"]: row["proof_grade"] for row in evidence["golden_traces"]},
+    )
+
+    expected_by_trace = trace_expectations(evidence)
+    service = CardDemoService(db_path)
+    probe_rows = build_runtime_probes(service, expected_by_trace)
+    runtime_probe_checks = [row for row in probe_rows if "check" in row]
+    runtime_probes = [row for row in probe_rows if "trace_id" in row]
+    checks.extend(runtime_probe_checks)
+
+    failed_checks = [row["check"] for row in checks if not row["passed"]]
+    report = {
+        "replay_version": "modern_carddemo_static_oracle_replay_v0",
+        "generated_utc": datetime.now(timezone.utc).replace(microsecond=0).isoformat(),
+        "source_root": str(source_root.resolve()),
+        "source_head": source_head,
+        "scratch_db_path": str(db_path.resolve()),
+        "seed_counts": seed_counts,
+        "summary": summary,
+        "capability_count": summary["capability_count"],
+        "grade_counts": summary["grade_counts"],
+        "gap_count": summary["gap_count"],
+        "golden_trace_count": len(evidence["golden_traces"]),
+        "edge_case_count": len(evidence["edge_cases"]),
+        "runtime_probe_count": len(runtime_probes),
+        "checks": checks,
+        "runtime_probes": runtime_probes,
+        "failed_checks": failed_checks,
+        "passed": not failed_checks,
+        "claim_limit": CLAIM_LIMIT,
+        "public_actions_allowed": False,
+        "evidence_hash": stable_json_hash(evidence),
+    }
+    report["replay_hash"] = stable_json_hash(report)
+    return report
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--source-root", type=Path, required=True)
+    parser.add_argument("--db-path", type=Path)
+    parser.add_argument("--out-dir", type=Path, required=True)
+    parser.add_argument("--source-head", default=DEFAULT_SOURCE_HEAD)
+    args = parser.parse_args()
+
+    args.out_dir.mkdir(parents=True, exist_ok=True)
+    db_path = args.db_path or args.out_dir / "static_oracle_replay.sqlite"
+    report = build_static_oracle_replay(args.source_root, db_path, source_head=args.source_head)
+    report_path = write_json(args.out_dir / "static_oracle_replay.json", report)
+    print(
+        json.dumps(
+            {
+                "replay": str(report_path),
+                "passed": report["passed"],
+                "replay_hash": report["replay_hash"],
+                "failed_checks": report["failed_checks"],
+                "claim_limit": report["claim_limit"],
+            },
+            indent=2,
+        )
+    )
+    if not report["passed"]:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

modern_code/tools/verify_clean_repro.py

@@ -0,0 +1,274 @@
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+import socket
+import subprocess
+import sys
+import time
+import urllib.request
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+SOURCE_HEAD = "59cc6c2fd7ebd7ef7925cad552a01a4b8b6e4d5e"
+
+
+def write_json(path: Path, payload: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2, sort_keys=True, default=str) + "\n", encoding="utf-8")
+
+
+def truncate(text: str, limit: int = 4000) -> str:
+    return text[-limit:] if len(text) > limit else text
+
+
+def ignore_modern(dir_path: str, names: list[str]) -> set[str]:
+    ignored = {"reports", "final_proof", ".dettools_checkpoints", "__pycache__"}
+    ignored.update(name for name in names if name.endswith(".pyc"))
+    ignored.update(name for name in names if name.startswith(".dettools_"))
+    ignored.update(name for name in names if name == "carddemo.sqlite")
+    return ignored & set(names)
+
+
+def ignore_source(dir_path: str, names: list[str]) -> set[str]:
+    ignored = {".git", "__pycache__"}
+    ignored.update(name for name in names if name.endswith(".pyc"))
+    return ignored & set(names)
+
+
+def copy_clean_workspace(modern_root: Path, source_root: Path, scratch_root: Path) -> dict[str, str]:
+    if scratch_root.exists():
+        raise SystemExit(f"scratch root already exists; choose another path: {scratch_root}")
+    source_copy = scratch_root / "source"
+    modern_copy = scratch_root / "modern_carddemo"
+    scratch_root.mkdir(parents=True)
+    shutil.copytree(source_root, source_copy, ignore=ignore_source)
+    shutil.copytree(modern_root, modern_copy, ignore=ignore_modern)
+    return {"scratch_root": str(scratch_root), "source_copy": str(source_copy), "modern_copy": str(modern_copy)}
+
+
+def run_command(name: str, command: list[str], cwd: Path, timeout: int = 120) -> dict[str, Any]:
+    started = time.monotonic()
+    result = subprocess.run(command, cwd=cwd, capture_output=True, text=True, timeout=timeout)
+    return {
+        "name": name,
+        "command": " ".join(command),
+        "cwd": str(cwd),
+        "returncode": result.returncode,
+        "passed": result.returncode == 0,
+        "duration_seconds": round(time.monotonic() - started, 3),
+        "stdout_tail": truncate(result.stdout),
+        "stderr_tail": truncate(result.stderr),
+    }
+
+
+def free_port(start: int = 8091, stop: int = 8999) -> int:
+    for port in range(start, stop + 1):
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            sock.settimeout(0.1)
+            if sock.connect_ex(("127.0.0.1", port)) != 0:
+                return port
+    raise SystemExit("no free local port found for clean server smoke")
+
+
+def fetch_json(url: str, timeout: float = 5.0) -> Any:
+    with urllib.request.urlopen(url, timeout=timeout) as response:
+        return json.loads(response.read().decode("utf-8"))
+
+
+def wait_for_server(port: int, timeout_seconds: float = 10.0) -> None:
+    deadline = time.monotonic() + timeout_seconds
+    last_error = ""
+    while time.monotonic() < deadline:
+        try:
+            fetch_json(f"http://127.0.0.1:{port}/api/health", timeout=1.0)
+            return
+        except Exception as exc:  # noqa: BLE001
+            last_error = str(exc)
+            time.sleep(0.25)
+    raise RuntimeError(f"server did not become healthy on port {port}: {last_error}")
+
+
+def run_server_smoke(modern_copy: Path, port: int) -> dict[str, Any]:
+    out_path = modern_copy / "server_smoke.out.log"
+    err_path = modern_copy / "server_smoke.err.log"
+    with out_path.open("w", encoding="utf-8") as stdout, err_path.open("w", encoding="utf-8") as stderr:
+        proc = subprocess.Popen(
+            [
+                sys.executable,
+                "-m",
+                "carddemo.cli",
+                "serve",
+                "--source-root",
+                "..\\source",
+                "--db-path",
+                ".\\carddemo.sqlite",
+                "--port",
+                str(port),
+            ],
+            cwd=modern_copy,
+            stdout=stdout,
+            stderr=stderr,
+            text=True,
+        )
+        try:
+            wait_for_server(port)
+            api_smoke = {
+                "health": fetch_json(f"http://127.0.0.1:{port}/api/health"),
+                "summary": fetch_json(f"http://127.0.0.1:{port}/api/summary"),
+                "mq_system_date": fetch_json(
+                    f"http://127.0.0.1:{port}/api/mq/system-date?now=2026-05-23T11:12:13"
+                ),
+                "batch_resource_setup_tranidx": fetch_json(
+                    f"http://127.0.0.1:{port}/api/batch/resource-setup?job=TRANIDX"
+                ),
+            }
+            checks = {
+                "health_ok": api_smoke["health"].get("status") == "ok",
+                "summary_customers_50": api_smoke["summary"]["counts"]["customers"] == 50,
+                "mq_date_reply": api_smoke["mq_system_date"]["reply_message"]
+                == "SYSTEM DATE : 05-23-2026SYSTEM TIME : 11:12:13",
+                "tranidx_key_contract": api_smoke["batch_resource_setup_tranidx"]["alternate_index"]["keys"]
+                == {"length": 26, "offset": 304},
+            }
+            return {
+                "passed": all(checks.values()),
+                "server_command": f"{sys.executable} -m carddemo.cli serve --source-root ..\\source --db-path .\\carddemo.sqlite --port {port}",
+                "port": port,
+                "checks": checks,
+                "api_smoke": api_smoke,
+                "stdout_log": str(out_path),
+                "stderr_log": str(err_path),
+            }
+        finally:
+            proc.terminate()
+            try:
+                proc.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+                proc.wait(timeout=5)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Verify CardDemo reproducibility from a clean copied workspace")
+    parser.add_argument("--modern-root", type=Path, default=Path(__file__).resolve().parents[1])
+    parser.add_argument("--source-root", type=Path, default=Path(__file__).resolve().parents[2] / "source")
+    parser.add_argument("--scratch-root", type=Path, default=None)
+    parser.add_argument("--out-path", type=Path, default=None)
+    parser.add_argument("--source-head", default=SOURCE_HEAD)
+    args = parser.parse_args()
+
+    modern_root = args.modern_root.resolve()
+    source_root = args.source_root.resolve()
+    timestamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    scratch_root = (args.scratch_root or modern_root.parent / f"clean_repro_{timestamp}").resolve()
+    out_path = (args.out_path or modern_root / "final_proof" / "CLEAN_REPRO_VERIFICATION.json").resolve()
+
+    copied = copy_clean_workspace(modern_root, source_root, scratch_root)
+    modern_copy = Path(copied["modern_copy"])
+    port = free_port()
+    commands = [
+        run_command(
+            "setup",
+            [sys.executable, "-m", "carddemo.cli", "init-db", "--source-root", "..\\source", "--db-path", ".\\carddemo.sqlite"],
+            modern_copy,
+        ),
+        run_command("test", [sys.executable, "-m", "unittest", "discover", "-s", "tests"], modern_copy, timeout=180),
+        run_command(
+            "receipt",
+            [
+                sys.executable,
+                "tools\\generate_receipts.py",
+                "--source-root",
+                "..\\source",
+                "--db-path",
+                ".\\carddemo.sqlite",
+                "--out-dir",
+                ".\\reports",
+            ],
+            modern_copy,
+            timeout=180,
+        ),
+        run_command(
+            "static_oracle_replay",
+            [
+                sys.executable,
+                "tools\\replay_static_oracles.py",
+                "--source-root",
+                "..\\source",
+                "--out-dir",
+                ".\\reports",
+                "--source-head",
+                args.source_head,
+            ],
+            modern_copy,
+            timeout=180,
+        ),
+        run_command(
+            "a_grade_promotion",
+            [
+                sys.executable,
+                "tools\\evaluate_a_grade_promotion.py",
+                "--source-root",
+                "..\\source",
+                "--out-dir",
+                ".\\final_proof",
+            ],
+            modern_copy,
+            timeout=180,
+        ),
+        run_command(
+            "no_cost_confidence",
+            [
+                sys.executable,
+                "tools\\build_no_cost_confidence.py",
+                "--source-root",
+                "..\\source",
+                "--out-dir",
+                ".\\final_proof",
+            ],
+            modern_copy,
+            timeout=180,
+        ),
+        run_command(
+            "package_final_proof",
+            [
+                sys.executable,
+                "tools\\package_final_proof.py",
+                "--source-root",
+                "..\\source",
+            ],
+            modern_copy,
+            timeout=180,
+        ),
+    ]
+    server_smoke = run_server_smoke(modern_copy, port)
+    report = {
+        "verification_version": "carddemo_clean_repro_verification_v0",
+        "generated_utc": datetime.now(timezone.utc).replace(microsecond=0).isoformat(),
+        "source_head": args.source_head,
+        "copied_workspace": copied,
+        "server_port": port,
+        "commands": commands,
+        "api_smoke_passed": server_smoke["passed"],
+        "api_smoke": server_smoke["api_smoke"],
+        "server_smoke": {
+            "passed": server_smoke["passed"],
+            "server_command": server_smoke["server_command"],
+            "checks": server_smoke["checks"],
+            "stdout_log": server_smoke["stdout_log"],
+            "stderr_log": server_smoke["stderr_log"],
+        },
+    }
+    report["passed"] = all(row["passed"] for row in commands) and server_smoke["passed"]
+    write_json(out_path, report)
+    print(json.dumps({"passed": report["passed"], "out_path": str(out_path), "scratch_root": str(scratch_root)}, indent=2))
+    if not report["passed"]:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()