deploy(hf): sync szl-holdings/a11oy@19cb88a6a814e7a54e9ec683e0b478397a595466 derived COPY set

Reusable Dockerfile-COPY-derived deploy from szl-holdings/a11oy 19cb88a6a814e7a54e9ec683e0b478397a595466.
Files: 1179 Pruned: 0
Derived from Dockerfile COPY sources (NO hand-maintained allowlist).

Signed-off-by: SZL Holdings <noreply@szlholdings.ai>
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

gdw_runtime.py

@@ -15,6 +15,7 @@ from typing import Any, Mapping, Optional
 from gdw_proofs import (
     export_proof_payload,
     export_receipt_projection,
+    sha256_json,
 )
 from gdw_workspace import GDWWorkspace
 
@@ -270,6 +271,34 @@ def _verify_effect_binding(
         raise ValueError("invalid effect binding: " + ",".join(errors))
 
 
+def _verify_legacy_proof_binding(
+    workspace: GDWWorkspace,
+    row: Mapping[str, Any],
+) -> None:
+    payload = row["payload"]
+    claimed_digest = str(payload.get("payload_sha256") or "")
+    unsigned_payload = dict(payload)
+    unsigned_payload.pop("payload_sha256", None)
+    if row["proposal_id"] != payload.get("proposal_id"):
+        raise ValueError("legacy proof proposal binding is invalid")
+    if row["payload_sha256"] != claimed_digest:
+        raise ValueError("legacy proof row digest is invalid")
+    if claimed_digest != sha256_json(unsigned_payload):
+        raise ValueError("legacy proof payload digest is invalid")
+    for field, expected in (
+        ("namespace", row["namespace"]),
+        ("owner_id", row["owner_id"]),
+    ):
+        if field in payload and payload[field] != expected:
+            raise ValueError(f"legacy proof {field} binding is invalid")
+    if (
+        "database_generation_id" in payload
+        and payload["database_generation_id"]
+        != workspace.database_generation_id
+    ):
+        raise ValueError("legacy proof database generation binding is invalid")
+
+
 def _export_effect(
     workspace: GDWWorkspace,
     row: Mapping[str, Any],
@@ -328,30 +357,39 @@ def drain_once(
         remaining = bounded - exported - failed
         if remaining <= 0:
             break
-        if not store.production:
-            for row in store.pending_proofs(
-                remaining,
-                namespace=namespace,
-                owner_id=owner_id,
-            ):
-                try:
-                    artifact = export_proof_payload(
-                        row["payload"],
-                        owner_id=owner_id,
-                    )
-                    store.mark_proof_exported(
-                        row["proposal_id"],
-                        artifact,
-                        _now(),
-                        namespace=namespace,
-                        owner_id=owner_id,
-                    )
-                    exported += 1
-                except Exception as exc:
-                    failed += 1
-                    errors.append(f"legacy:{type(exc).__name__}")
-                if exported + failed >= bounded:
-                    break
+        for row in store.pending_proofs(
+            remaining,
+            namespace=namespace,
+            owner_id=owner_id,
+        ):
+            try:
+                _verify_legacy_proof_binding(store, row)
+                artifact = export_proof_payload(
+                    row["payload"],
+                    artifact_id=row["payload_sha256"],
+                    owner_id=owner_id,
+                )
+                artifact.update(
+                    {
+                        "migration_status": "LEGACY_PROOF_PRESERVED",
+                        "source_payload_sha256": row["payload_sha256"],
+                    }
+                )
+                store.mark_proof_exported(
+                    row["proposal_id"],
+                    artifact,
+                    _now(),
+                    expected_payload=row["payload"],
+                    expected_payload_sha256=row["payload_sha256"],
+                    namespace=namespace,
+                    owner_id=owner_id,
+                )
+                exported += 1
+            except Exception as exc:
+                failed += 1
+                errors.append(f"legacy:{type(exc).__name__}")
+            if exported + failed >= bounded:
+                break
 
         remaining = bounded - exported - failed
         if remaining <= 0:

gdw_workspace.py

@@ -2189,18 +2189,22 @@ class GDWWorkspace:
         artifact: Dict[str, Any],
         exported_at: str,
         *,
+        expected_payload: Dict[str, Any],
+        expected_payload_sha256: str,
         namespace: Optional[str] = None,
         owner_id: Optional[str] = None,
     ) -> None:
         ns, owner = self._identity(namespace, owner_id)
         artifact_text = _json_text(artifact)
+        expected_payload_text = _json_text(expected_payload)
         with self.transaction() as connection:
             updated = connection.execute(
                 """
                 UPDATE proof_outbox
                 SET status = 'EXPORTED', artifact_json = ?, exported_at = ?
                 WHERE namespace = ? AND owner_id = ? AND proposal_id = ?
-                      AND status = 'PENDING'
+                      AND status = 'PENDING' AND payload_json = ?
+                      AND payload_sha256 = ?
                 """,
                 (
                     artifact_text,
@@ -2208,10 +2212,14 @@ class GDWWorkspace:
                     ns,
                     owner,
                     proposal_id,
+                    expected_payload_text,
+                    expected_payload_sha256,
                 ),
             )
             if updated.rowcount != 1:
-                raise RuntimeError("proof is absent, exported, or owned elsewhere")
+                raise RuntimeError(
+                    "proof is absent, changed, exported, or owned elsewhere"
+                )
             self._reserve_usage(
                 connection,
                 ns,