feat: appraise pinned Proofable fetch evidence offline

integrations/alakris-authority-comparison/README.md

@@ -13,7 +13,7 @@ python3.12 -m venv .venv
 .venv/bin/python check_package.py --fetch
 ```
 
-The single check command downloads pinned fixtures, runs the tests, writes author appraisals, verifies the corrected Proofable packet, preserves the historical Proofable hash failure, and validates TRACE reference shapes. To rerun individual stages:
+The single check command downloads pinned fixtures, runs the tests normally and under `-O`, validates the earlier author packets while retaining their historical reports, writes the separate positive fetch appraisal, preserves the historical Proofable hash failure, and validates TRACE reference shapes. To rerun individual stages (the `runner.py` commands explicitly regenerate the named historical appraisal):
 
 ```sh
 .venv/bin/python fetch_fixtures.py --out fixtures
@@ -24,6 +24,7 @@ The single check command downloads pinned fixtures, runs the tests, writes autho
 .venv/bin/python runner.py mintid --evidence fixtures/mintid \
   --record revocation-trace-local-20261005T094532Z --output results/mintid-author-local.json
 .venv/bin/python runner.py proofable --evidence fixtures/proofable --output results/proofable-author-oct8.json
+.venv/bin/python proofable_fetch.py --input fixtures/proofable-fetch --output results/proofable-fetch-author.json
 .venv/bin/python create_references.py --lock fixtures/download-lock.json --output results/trace-reference-shapes.json
 ```
 
@@ -64,6 +65,20 @@ The corrected Proofable Oct 8 packet discloses 11 portable envelopes. The adapte
 
 The verifier is vendored unchanged from the reviewed reader revision `2b54ee47491f0d1a86c7d9f47d434f8f02622043`; see `PORTABLE_ENVELOPE_NOTICE.txt` and its retained Apache-2.0 license. `fixtures/proofable` uses docs commit `9851059900e29ba701bb0f4df2bf89a2107f430c`. `fixtures/proofable-historical` preserves the earlier `3a45f026` packet, and `results/proofable-author.json` preserves its checksum FAIL. New results are written separately to `results/proofable-author-oct8.json`.
 
+### Separate Proofable positive fetch appraisal
+
+`proofable_fetch.py` reads the ten unmodified files in [the retained Oct 24 fetch packet](https://github.com/proofable/docs/tree/e6eb5b9307be24a5d82cc7490f647f0c98e2d24a/public/evidence/aaif/authority-at-dispatch/2026-10-24-fetch-route), at exact publication `e6eb5b9307be24a5d82cc7490f647f0c98e2d24a`. Its per-file SHA-256 pins include the publisher's `SHA256SUMS`, README and verifier script. Downloaded scripts are retained as bytes and never executed. The separate eight-case served run on revision `61724c9f...` is not an input to this adapter.
+
+The command above exits **0** only for the fixed bytes, exact nine-entry checksum inventory, two valid EIP-191/qHash/DID-chain envelopes, matching declared signer/context, request projection and retained response/job consistency checks. Source-file digests in the output identify the tested appraiser and its helper/test bytes. Unsafe or missing paths, oversized files, duplicate JSON keys (including JSON inside signed content), nonfinite constants and ambiguous SSE messages fail closed. No vendor API, target URL, credential or downloaded code is used. Output must be outside the input packet and is replaced atomically from a fresh temporary file, so an existing output hard link cannot overwrite a packet inode.
+
+The publisher reports hosted MCP `0.1.7`, service revision `18433a48d74af913550de7a018f02c7c724cc1c9`, and job `d259c7cc-0701-4624-a148-77b149f84e06`. These deployment fields are unsigned publisher claims, not independent binary attestation. The signed dispatch statement commits to SHA-256 of the documented `JSON.stringify` projection, in its specified key order. The URL occurs in `prompt`, the acceptance criterion is the generic `target-ack`, and the full returned marker is signed only in the terminal receipt. `runNowFirst` and the `acceptance.criteria` alias are outside that digest projection. The original publisher README's marker wording is retained unchanged; the appraisal does not infer a precommitment to the full marker.
+
+`integrity: PASS` means fixed artifact bytes and checksum coverage match. `positive_dispatch_appraisal: PASS` additionally means the signature, request and correlation checks pass. **Neither means scenario conformance.** The four existing scenario cases each remain `UNMET`, with all fourteen fields and explicit missing-measurement reasons. EO01 is unestablished and `not_measured` for this positive run; the historical appraisals and their earlier N/A fields are not rewritten or treated as a passing EO01 result.
+
+The signer is bound to its declared DID/wallet, but attribution of that wallet to Proofable is `not_measured` without a separately verified canonical trust source. No caller-provided wallet flag can promote that status. Grant and agent-identity proof records are absent. The decision's `jobId` is null; the unsigned create response correlates its qHash to the job ID, and identical requests share a digest. The service reports one GET and a returned marker; there is no executor-signed GET, retained external target ingress log, independent target witness, target-commit authority check or revocation-latency measurement. Service acceptance/completeness flags do not override these gaps. `independent_live_reproduction` and `independent_comparison_completed` remain false.
+
+Negative controls independently generate signed envelopes using local test keys. They check altered request digests, a different validly signed receipt request, bad signatures/qHashes/DID bindings, different valid signers/chains/principals and unsigned decision/job join mismatches independently of outer artifact hashes. A separate tamper control keeps semantic checks valid while the publication hash fails. These controls exercise the offline appraiser, not Proofable's live enforcement.
+
 ## Native implementation runs
 
 Use the vendor's pinned release and official sandbox only, with synthetic identities. The MintID public command is:

integrations/alakris-authority-comparison/RESULTS.md

@@ -6,6 +6,8 @@ This contribution is an evidence appraiser and synthetic boundary fixture, with
 
 ## Package checks
 
+The figures in this section describe the original 2026-10-06 run. The separate 2026-10-27 appraisal below records the current package check scope; original author and native-run reports remain unchanged.
+
 - Environment: isolated Frankfurt Linux task checkout, Python 3.12.15.
 - Released dependency: `agentrust-trace==0.11.0`. Inputs are `requirements.txt`; reproducible dependency versions and distribution hashes are in `requirements.lock`. Actual installed versions are in `results/python-packages.txt`.
 - Command: `python check_package.py --fetch` (or without `--fetch` to reuse pinned downloaded bytes).
@@ -63,3 +65,31 @@ Retry raw JSONL SHA-256: `e0618e6fca7322f7e8168ce48b6ebbe8fc9a5a7b8dfdf6bc305254
 - Implementation-side dispatch/effect adapters and an independent committed-effect observer, including lost response after a committed write.
 - Same-input matched runs, original deadlines/fallback scope, retries/duplicates and useful work lost.
 - Maintainer review, upstream issue/PR publication and links from AAIF WG #13. No Verified badge is requested by this packet.
+
+## Separate Proofable positive-fetch appraisal — 2026-10-27
+
+Input: `proofable/docs@e6eb5b9307be24a5d82cc7490f647f0c98e2d24a`, `public/evidence/aaif/authority-at-dispatch/2026-10-24-fetch-route`. All ten original files are retained by the downloader, with fixed SHA-256 pins in `proofable_fetch.py` and immutable source URLs in `fixtures/download-lock.json`. Output: `results/proofable-fetch-author.json`, separate from the historical and corrected Oct 8 reports. Exact appraiser/helper/test source hashes are included in the new report.
+
+Commands in a fresh Python 3.12 hash-locked environment:
+
+```sh
+.venv/bin/python check_package.py --fetch
+.venv/bin/python proofable_fetch.py --input fixtures/proofable-fetch --output results/proofable-fetch-author.json
+```
+
+`check_package.py` runs the complete unittest suite normally and under `-O`; the retained transcript is `results/tests.txt`, and installed dependency versions are `results/python-packages.txt`. The pinned fetch appraisal requires ten matching byte hashes, exact publisher checksum coverage, both envelope signatures/qHashes/DID-chain bindings, same declared signer/context, both request-digest reconstructions and unsigned create/job consistency. The generated-key negative controls test these checks independently of fixed artifact hashes. TRACE validation now covers all thirty immutable source pointers and still emits no TRACE record or attestation.
+
+| Result dimension | Meaning retained in the new report |
+|---|---|
+| Fixed publication integrity | Ten pinned artifacts and exact nine-entry publisher checksum inventory. |
+| Positive dispatch appraisal | Offline validation of two signed statements and request/correlation consistency; not a hosted replay. |
+| Deployment | Publisher claims MCP `0.1.7`, revision `18433a48d74af913550de7a018f02c7c724cc1c9`; no binary attestation. |
+| Service signing key | Signer/DID consistency verified; attribution to Proofable remains `not_measured`. |
+| Request commitment | Unique URL and generic criterion are committed; full returned marker is signed only in terminal receipt. |
+| Decision to job | Decision `jobId=null`; create-response join is unsigned and correlation-only. |
+| Authority chain | Grant and agent-identity qHash references present; their proof records and validation absent. |
+| Four comparison scenarios | All remain `UNMET`; a positive fetch establishes no veto, stale/revoked, unreachable-authority or post-dispatch denial result. |
+| EO01, target effects, latency | `not_measured`/unestablished; no operator-owned observer, target ingress log, commit-time recheck or revocation timing. |
+| Execution custody | Proofable-operated run, local offline reader; independent live reproduction and independent comparison remain false. |
+
+The source publisher README is preserved byte-identically despite its inaccurate statement that the full marker is inside the prompt. The request contains only the unique URL and generic `target-ack` criterion. The separate eight-case served packet from revision `61724c9f...` is not imported or combined with this run. Existing historical checksum FAILs, old N/A appraisals, original raw inputs and native MintID histories retain their original meaning. The check command validates old source packets afresh without rewriting the four historical author JSON reports; those committed outputs remain byte-identical rather than importing unrelated field-state changes from later reader versions. No live service/target call or scenario/operator acceptance is established by these offline checks.

integrations/alakris-authority-comparison/check_package.py

@@ -6,6 +6,7 @@
 import sys
 
 from runner import mintid, proofable
+from proofable_fetch import appraise as proofable_fetch
 
 ROOT = Path(__file__).resolve().parent
 
@@ -15,24 +16,25 @@ def main():
     args = parser.parse_args()
     if args.fetch:
         subprocess.run([sys.executable, 'fetch_fixtures.py', '--out', 'fixtures'], cwd=ROOT, check=True)
-    for path in ('fixtures/download-lock.json', 'fixtures/proofable/manifest.json', 'fixtures/mintid'):
+    for path in ('fixtures/download-lock.json', 'fixtures/proofable/manifest.json', 'fixtures/mintid', 'fixtures/proofable-fetch/SHA256SUMS'):
         if not (ROOT / path).exists():
             parser.error('fixtures are required; rerun with --fetch')
     results = ROOT / 'results'
     results.mkdir(exist_ok=True)
     with (results / 'tests.txt').open('w') as output:
-        subprocess.run([sys.executable, '-m', 'unittest', '-v'], cwd=ROOT, stdout=output, stderr=subprocess.STDOUT, check=True)
+        for flags in ([], ['-O']):
+            output.write('Command: python ' + ' '.join(flags + ['-m', 'unittest', '-v']) + '\n')
+            output.flush()
+            subprocess.run([sys.executable, *flags, '-m', 'unittest', '-v'], cwd=ROOT, stdout=output, stderr=subprocess.STDOUT, check=True)
     with (results / 'synthetic-reference.json').open('w') as output:
         subprocess.run([sys.executable, 'reference_adapter.py'], cwd=ROOT, stdout=output, check=True)
     records = [('revocation-trace-testnet-20261006T073712Z', 'mintid-author-testnet.json'),
                ('revocation-trace-local-20261005T094532Z', 'mintid-author-local.json')]
     for name, filename in records:
         report = mintid(ROOT / 'fixtures/mintid', name)
-        (results / filename).write_text(json.dumps(report, indent=2) + '\n')
         if report['integrity'] != 'PASS':
             raise RuntimeError('MintID publisher bytes changed: ' + name)
     report = proofable(ROOT / 'fixtures/proofable-historical')
-    (results / 'proofable-author.json').write_text(json.dumps(report, indent=2) + '\n')
     mismatches = [c for c in report['checks'] if not c['match']]
     # Both SHA256SUMS and manifest assert the same trace hash. Preserve both failures.
     expected = 'd749cf16fe8dd599f528e21e95863b930004a0b3f0a9882695e3d3b03e8c2183'
@@ -41,12 +43,22 @@ def main():
     if report['integrity'] != 'FAIL' or not known or not report['record_count_consistent']:
         raise RuntimeError('Pinned Proofable evidence changed; review rather than replace expected hashes')
     corrected = proofable(ROOT / 'fixtures/proofable')
-    (results / 'proofable-author-oct8.json').write_text(json.dumps(corrected, indent=2) + '\n')
+    # These existing author reports are historical records. Validate their source
+    # packets afresh, but do not replace past appraisals with today's field states.
     if corrected['integrity'] != 'PASS' or corrected['envelope_appraisal']['valid'] is not True:
         raise RuntimeError('Corrected Proofable appraisal failed')
+    fetch_report = proofable_fetch(ROOT / 'fixtures/proofable-fetch')
+    (results / 'proofable-fetch-author.json').write_text(json.dumps(fetch_report, indent=2) + '\n')
+    if fetch_report['integrity'] != 'PASS' or fetch_report['positive_dispatch_appraisal'] != 'PASS':
+        raise RuntimeError('Pinned Proofable fetch appraisal failed')
+    if fetch_report['scenario_conformance'] != 'UNMET' or fetch_report['independent_live_reproduction']:
+        raise RuntimeError('Positive fetch cannot establish independent scenario conformance')
     subprocess.run([sys.executable, 'create_references.py', '--lock', 'fixtures/download-lock.json', '--output', 'results/trace-reference-shapes.json'], cwd=ROOT, check=True)
+    with (results / 'python-packages.txt').open('w') as output:
+        subprocess.run([sys.executable, '-m', 'pip', 'freeze'], cwd=ROOT, stdout=output, check=True)
     print(json.dumps({'package_checks': 'PASS', 'mintid_author_bytes': 'PASS',
                       'proofable_author_bytes': 'FAIL', 'known_failure_preserved': True, 'proofable_oct8_bytes_and_envelopes': 'PASS',
+                      'proofable_fetch_positive_dispatch': 'PASS', 'proofable_fetch_four_scenarios': 'UNMET',
                       'independent_comparison_completed': False}))
 
 if __name__ == '__main__':

integrations/alakris-authority-comparison/fetch_fixtures.py

@@ -5,6 +5,8 @@
 from pathlib import Path
 import urllib.request
 
+from proofable_fetch import PINS as FETCH_PINS, PUBLICATION as FETCH_PUBLICATION, SOURCE_URL as FETCH_SOURCE_URL
+
 PROOFABLE = '9851059900e29ba701bb0f4df2bf89a2107f430c'
 HISTORICAL_PROOFABLE = '3a45f026fd0c06b9d1d411c053597584b6b1c3dc'
 MINTID = 'b678e5cd6b5736e1795fd18d497fd8e501272dcd'
@@ -22,10 +24,15 @@ def fetch(out):
     for record in RECORDS:
         for suffix in ['.jsonl', '.md', '.manifest.json']:
             files['mintid/' + record + suffix] = f'https://gitlab.com/mintid/mintid/-/raw/{MINTID}/test-harness/trace/records/{record}{suffix}'
-    lock = {'proofable_docs_commit': PROOFABLE, 'mintid_public_commit': MINTID, 'files': []}
+    for name in FETCH_PINS:
+        files['proofable-fetch/' + name] = FETCH_SOURCE_URL + '/' + name
+    lock = {'proofable_docs_commit': PROOFABLE, 'mintid_public_commit': MINTID,
+            'proofable_fetch_docs_commit': FETCH_PUBLICATION, 'files': []}
     for name, url in files.items():
         with urllib.request.urlopen(url, timeout=60) as response:
             content = response.read()
+        if name.startswith('proofable-fetch/') and hashlib.sha256(content).hexdigest() != FETCH_PINS[Path(name).name]:
+            raise ValueError('Pinned Proofable fetch bytes changed: ' + name)
         path = out / name
         path.parent.mkdir(parents=True, exist_ok=True)
         path.write_bytes(content)