@mriekki/project-forge 4.20.0 → 4.22.0

package/assets/components.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 2,
   "package": "@mriekki/project-forge",
-  "version": "4.20.0",
+  "version": "4.22.0",
   "defaultProfile": "greenfield-project",
   "profiles": {
     "greenfield-project": {
@@ -21,7 +21,7 @@
       "canonicalDescriptor": "distributions/greenfield-workspace.json"
     },
     "deployment": {
-      "revision": "977ada7310f649adea34059381339012a0c0daaf",
+      "revision": "2258794181483747ed11a2c3c3226d6e66e1b9bb",
       "distribution": "greenfield-project",
       "descriptor": "assets/deployment/distribution.json",
       "sourceRoot": "assets/generated/deployment",

package/assets/generated/ASSEMBLY.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 2,
   "package": "@mriekki/project-forge",
-  "version": "4.20.0",
+  "version": "4.22.0",
   "components": {
     "core": {
       "revision": "4c74c1801b82d3aa438447d392024d32ca5697b0",
@@ -361,7 +361,7 @@
       ]
     },
     "deployment": {
-      "revision": "977ada7310f649adea34059381339012a0c0daaf",
+      "revision": "2258794181483747ed11a2c3c3226d6e66e1b9bb",
       "distribution": "greenfield-project",
       "files": [
         {
@@ -392,7 +392,7 @@
         {
           "source": "src/project_forge_deployment/app_cli.py",
           "destination": "tools/project-forge-deployment/project_forge_deployment/app_cli.py",
-          "sha256": "f27704c80b1eff45888bf56745bcf8755f2fad88851147600af7056953757825"
+          "sha256": "b44ec913fd1080ff66bff6643d2d9fad17262725c0f35557c56f52c86090c060"
         },
         {
           "source": "src/project_forge_deployment/app_deployment.py",
@@ -402,12 +402,12 @@
         {
           "source": "src/project_forge_deployment/app_runtime.py",
           "destination": "tools/project-forge-deployment/project_forge_deployment/app_runtime.py",
-          "sha256": "73736aada7c3db0e2a7c74a3e88990316b89e6c34a71b4997cdc4c79c7e31708"
+          "sha256": "6f4ae7f663dc7a4e51225c1420f7aa6be5d2b77445b792f9e4495ba3eeb059ad"
         },
         {
           "source": "src/project_forge_deployment/app_runtime_remote.py",
           "destination": "tools/project-forge-deployment/project_forge_deployment/app_runtime_remote.py",
-          "sha256": "791cc7592cff93555f7b6facdd31fbe58de5e711732d9dfcb9321500a0d79cdf"
+          "sha256": "5b6ddffcc1105d3a401ae17456cdfdb279c3005bfcb6c81bbd1eabc27479de05"
         },
         {
           "source": "src/project_forge_deployment/app_runtime_workstation.py",
@@ -437,12 +437,12 @@
         {
           "source": "src/project_forge_deployment/cloudflare_ingress.py",
           "destination": "tools/project-forge-deployment/project_forge_deployment/cloudflare_ingress.py",
-          "sha256": "d07c79b7f9f6c9a0f9b417fd0a1d4502101075b128a12d23b2791c31e03d4f01"
+          "sha256": "31541e115f474fd3bd2a426eac1ca1beea429633c6ecc48afeace025a85054a9"
         },
         {
           "source": "src/project_forge_deployment/cloudflare_ingress_remote.py",
           "destination": "tools/project-forge-deployment/project_forge_deployment/cloudflare_ingress_remote.py",
-          "sha256": "73d9f68cbece33155ccac8ce2e24da8f0ec6698a7b66fba18cb9bf38734ea686"
+          "sha256": "19de0d8c04b7ad0006b8bc341eabd52a5eaa50c0e0bacdc9edb856de101dd259"
         },
         {
           "source": "src/project_forge_deployment/cloudflare_route_apply.py",
@@ -502,7 +502,7 @@
         {
           "source": "src/project_forge_deployment/ingress_cli.py",
           "destination": "tools/project-forge-deployment/project_forge_deployment/ingress_cli.py",
-          "sha256": "973b89daa7e57d925f0be56fbfc0dc4c6f79ab082036c7fb26462691f2f16d02"
+          "sha256": "069a7e5a4c7921448e6965ebff2df8b38a9aba77aaff1154a54969ab0e234324"
         },
         {
           "source": "src/project_forge_deployment/keys.py",
@@ -647,7 +647,7 @@
         {
           "source": "docs/CLOUDFLARE_INGRESS.md",
           "destination": "docs/project-forge/CLOUDFLARE_INGRESS.md",
-          "sha256": "b47bfb1ef1dcd7be3c501b88add0dea675907ce3f9e65cf7852c5ffddbe0ce46"
+          "sha256": "396327ae00bf4a54eeaea6eec8c07a17af6084eed5c4d0be97b55b29bd0160ff"
         },
         {
           "source": "docs/DEVELOPER_ENVIRONMENTS.md",

package/assets/generated/deployment/docs/CLOUDFLARE_INGRESS.md

@@ -200,11 +200,45 @@ without a zone or public hostname. Once a domain is registered and active in Clo
 
 The shared Cloudflare zone is environment infrastructure and should not be copied into every Project as a credential-like default. The exact application hostname remains Project/environment state.
 
-## Experimental authenticated public-origin mode (new scopes only)
+## Experimental authenticated public-origin mode
 
 For an isolated test scope, `ingress cloudflare configure` supports `--authenticated-origin`. This explicit opt-in provisions a private Caddy Unix listener and mounts its socket directory only in the pinned cloudflared connector. Public hostname rules use `unix:/run/project-forge-origin/origin.sock` and the public hostname as Host; the LAN TCP listener and the existing default mode remain unchanged. The remote adapter derives each authenticated route's upstream from its still-owned LAN registry entry and strips/replaces forwarding headers before proxying.
 
-**Not a supported Production setting yet:** origin mount possession is not end-user login. Real pinned cloudflared edge-to-app forwarding, canonical client-IP semantics, app proxy-peer trust, socket replacement, and rollback still need live proof. Do not grant the socket mount to unrelated containers or treat forwarded IP headers as an authorization credential. An installed ingress scope cannot switch modes in place; use a new dedicated scope and the normal host/route write gates. See the canonical Kit's `docs/EXPERIMENTAL_AUTHENTICATED_ORIGIN.md` and issue #78 for the detailed evidence boundary.
+**Not a supported Production setting yet:** origin mount possession is not end-user login. Real pinned cloudflared edge-to-app forwarding, canonical client-IP semantics, app proxy-peer trust, socket replacement, and rollback still need live proof. Do not grant the socket mount to unrelated containers or treat forwarded IP headers as an authorization credential.
+
+An existing legacy scope can be migrated without replacing its tunnel, public routes, DNS/CNAME records, or unrelated tunnel rules. The operation has its own read-only plan, exact interactive authorization, and guarded apply:
+
+```text
+project-forge-deploy ingress cloudflare migrate-authenticated-origin <target> \
+  --scope production \
+  --zone example.com
+```
+
+Before planning, the operator must stop all Cloudflare dashboard/API tunnel-configuration writers for this scope. The CLI asks for an exact scope-bound freeze-active acknowledgment before making plan reads, and the programmatic planning API requires the corresponding `change_freeze_active_acknowledgement`, for example:
+
+```text
+[CLOUDFLARE EXTERNAL CHANGE FREEZE] ACTIVE scope=production
+```
+
+The freeze must remain in effect through apply, verification, and any rollback or recovery. It is an external operational prerequisite: the Deployment Kit cannot enforce it, identify all external writers, or prove that they are stopped. Cloudflare's full-configuration PUT has no compare-and-swap; pre-write snapshots and post-write checks do not prevent an external write from racing between a read and PUT. Do not start the operation unless this freeze can be maintained.
+
+The plan requires every host-registered route to match one exact Project Forge legacy provider rule and one exact owned DNS record. Conflicting/unowned rules for managed hostnames, missing or duplicate routes, stale host/provider/DNS snapshots, or incomplete host migration evidence stop the operation. Other provider rules remain unchanged; no DNS write or tunnel creation occurs. Apply holds the existing per-scope host lock, prepares the connector-only socket and sanitized Caddy routes first, then changes only the exact managed Cloudflare rules. It rechecks ownership immediately before each phase and verifies the unchanged tunnel, route and DNS identities plus the socket/header contract afterward. These checks are defense in depth, not enforcement of the external freeze. There is no generic `--yes` bypass; the CLI first requires:
+
+```text
+[CLOUDFLARE AUTHENTICATED ORIGIN MIGRATION]
+```
+
+After showing the plan, the CLI separately requires the migration authorization and an exact freeze acknowledgment bound to the reviewed scope and snapshot context, for example:
+
+```text
+[CLOUDFLARE EXTERNAL CHANGE FREEZE] scope=production context=<plan-specific digest>
+```
+
+The programmatic apply API likewise requires `change_freeze_acknowledgement`; migration authorization alone is insufficient. The bound acknowledgment prevents accidental reuse for a different scope/plan, but is an operator assertion only—not a lock on Cloudflare. If the provider update is confirmed unchanged, a newly prepared host phase is rolled back from a protected host receipt. If provider state is uncertain or differs from both reviewed states, the host remains authenticated with its receipt retained; maintain the external freeze and do not hand-edit or rerun blindly. Re-plan/resume or roll back only after inspecting current state; keep the freeze until recovery is complete. This migration still does not establish an application identity/login flow or replace disposable application/database state.
+
+Final migration output labels its evidence **structural-only**: it checks socket metadata, connector mount configuration, Caddy configuration, and the generated sanitized route files. It does not prove that the running pinned cloudflared connector can forward an HTTP request over that socket or that an application receives the intended headers. Live socket forwarding and end-to-end readiness remain unproven.
+
+See `docs/EXPERIMENTAL_AUTHENTICATED_ORIGIN.md` and issue #78 for the detailed evidence boundary. For a new isolated scope, `configure --authenticated-origin` and the normal route gates remain unchanged.
 
 ## Current cloudflared runtime
 

package/assets/generated/deployment/src/project_forge_deployment/app_cli.py

@@ -49,6 +49,16 @@ def _parse_env(items: list[str]) -> list[tuple[str, str]]:
     return result
 
 
+def _parse_materials(items: list[str]) -> list[tuple[str, str]]:
+    values: list[tuple[str, str]] = []
+    for item in items:
+        if "=" not in item:
+            raise DeploymentKitError("--read-only-material requires NAME=/absolute/container/directory.")
+        name, target = item.split("=", 1)
+        values.append((name, target))
+    return values
+
+
 def _confirm(args: argparse.Namespace, phrase: str, action: str) -> None:
     if args.yes:
         return
@@ -91,6 +101,13 @@ def _add_runtime_contract(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--health-path", required=True)
     parser.add_argument("--run-as", required=True)
     parser.add_argument("--data-container-path")
+    parser.add_argument(
+        "--read-only-material",
+        action="append",
+        default=[],
+        metavar="NAME=/container/directory",
+        help="Opt-in root-owned remote material directory; source derived from Project/environment/name",
+    )
     parser.add_argument(
         "--env",
         action="append",
@@ -185,6 +202,7 @@ def main(argv: list[str] | None = None) -> int:
             persistence_mode=args.persistence_mode,
             data_container_path=args.data_container_path,
             environment_variables=_parse_env(args.env),
+            read_only_materials=_parse_materials(args.read_only_material),
         )
         assert_app_spec_matches_persistence(args.name, spec)
 

package/assets/generated/deployment/src/project_forge_deployment/app_runtime.py

@@ -19,6 +19,8 @@ from .app_runtime_remote import REMOTE_SCRIPT
 
 APP_ROOT = "/srv/project-forge-apps"
 APP_SCHEMA_VERSION = 1
+# Operator-provisioned remote sources: never workstation paths or auto-created directories.
+REMOTE_MATERIAL_ROOT = "/srv/project-forge-material"
 APP_DEPLOY_WRITE_PHRASE = "[APP DEPLOY WRITE]"
 PRODUCTION_APP_DEPLOY_WRITE_PHRASE = "[PRODUCTION APP DEPLOY]"
 
@@ -84,6 +86,67 @@ def _container_path(value: str | None) -> str | None:
     return value.rstrip("/") or "/"
 
 
+
+def _normalize_read_only_materials(
+    materials: Iterable[tuple[str, str]] | None,
+    *,
+    data_path: str | None,
+) -> list[dict[str, str]]:
+    if materials is None:
+        return []
+    result: list[dict[str, str]] = []
+    names: set[str] = set()
+    paths: list[str] = []
+    for name, target in materials:
+        if len(result) >= 8:
+            raise DeploymentKitError("Remote read-only material mount count must not exceed eight.")
+        name = _slug(name, "read-only material name")
+        if name in names:
+            raise DeploymentKitError(f"Duplicate read-only material name: {name}")
+        if not isinstance(target, str) or _CONTAINER_PATH_RE.fullmatch(target) is None:
+            raise DeploymentKitError("Read-only material target must be a safe absolute container directory.")
+        parts = target.split("/")[1:]
+        if not parts or any(part in {"", ".", ".."} for part in parts):
+            raise DeploymentKitError("Read-only material target must be normalized and cannot be root.")
+        if parts[0] in {"proc", "sys", "dev", "run"} or parts[:2] == ["var", "run"]:
+            raise DeploymentKitError("Read-only material cannot mask a container system runtime directory.")
+        for other in paths + ([data_path] if data_path else []):
+            if target == other or target.startswith(other.rstrip("/") + "/") or other.startswith(target + "/"):
+                raise DeploymentKitError("Read-only material target overlaps another mount.")
+        names.add(name)
+        paths.append(target)
+        result.append({"name": name, "containerPath": target})
+    return sorted(result, key=lambda item: item["name"])
+
+
+def _material_evidence_for_spec(name: str, spec: dict[str, Any]) -> dict[str, str] | None:
+    materials = spec.get("readOnlyMaterials")
+    if not materials:
+        return None
+    profile = load_profile(name)
+    evidence = verify_access(profile)
+    output = _run_remote(profile, evidence["address"], "material-inspect", spec=spec)
+    observed: dict[str, str] = {}
+    for line in output.splitlines():
+        parts = line.split("\t")
+        if len(parts) != 3 or parts[0] != "MATERIAL":
+            raise DeploymentKitError("Malformed remote material source evidence.")
+        _, material_name, identity = parts
+        if not re.fullmatch(r"[a-z0-9](?:[a-z0-9-]*[a-z0-9])?", material_name) or not re.fullmatch(r"[0-9]+:[0-9]+", identity):
+            raise DeploymentKitError("Malformed remote material source identity.")
+        if material_name in observed:
+            raise DeploymentKitError("Duplicate remote material source evidence.")
+        observed[material_name] = identity
+    if set(observed) != {item["name"] for item in materials}:
+        raise DeploymentKitError("Remote material inspection omitted or added a source.")
+    return dict(sorted(observed.items()))
+
+
+def _verify_material_evidence(name: str, plan: dict[str, Any]) -> None:
+    if plan["spec"].get("readOnlyMaterials"):
+        if _material_evidence_for_spec(name, plan["spec"]) != plan["readOnlyMaterialEvidence"]:
+            raise DeploymentKitError("Remote material directory identity changed after planning; review a new plan.")
+
 def _normalize_environment_variables(items: dict[str, str] | Iterable[tuple[str, str]]) -> dict[str, str]:
     pairs = items.items() if isinstance(items, dict) else items
     result: dict[str, str] = {}
@@ -111,6 +174,7 @@ def normalize_app_spec(
     persistence_mode: str,
     data_container_path: str | None,
     environment_variables: dict[str, str] | Iterable[tuple[str, str]],
+    read_only_materials: Iterable[tuple[str, str]] | None = None,
 ) -> dict[str, Any]:
     if persistence_mode not in {"none", "directory"}:
         raise DeploymentKitError("persistenceMode must be 'none' or 'directory'.")
@@ -135,6 +199,9 @@ def normalize_app_spec(
         },
         "environmentVariables": _normalize_environment_variables(environment_variables),
     }
+    materials = _normalize_read_only_materials(read_only_materials, data_path=data_path)
+    if materials:
+        spec["readOnlyMaterials"] = materials
     spec["specSha256"] = _spec_sha(spec)
     return spec
 
@@ -150,8 +217,13 @@ def _b64(value: str) -> str:
     return base64.b64encode(value.encode("utf-8")).decode("ascii")
 
 
-def build_remote_script(spec: dict[str, Any] | None = None) -> str:
+def build_remote_script(
+    spec: dict[str, Any] | None = None, *, expected_materials: dict[str, str] | None = None,
+) -> str:
     env_keys: list[str] = []
+    material_names: list[str] = []
+    material_targets: list[str] = []
+    material_expected: list[str] = []
     env_values: list[str] = []
     desired = {
         "ownerRepo": "",
@@ -183,9 +255,14 @@ def build_remote_script(spec: dict[str, Any] | None = None) -> str:
         for key, value in spec["environmentVariables"].items():
             env_keys.append(_b64(key))
             env_values.append(_b64(value))
+        for item in spec.get("readOnlyMaterials", []):
+            material_names.append(_b64(item["name"]))
+            material_targets.append(_b64(item["containerPath"]))
+            material_expected.append((expected_materials or {}).get(item["name"], ""))
 
     replacements = {
         "__APP_ROOT__": APP_ROOT,
+        "__MATERIAL_ROOT__": REMOTE_MATERIAL_ROOT,
         "__APP_SCHEMA_VERSION__": str(APP_SCHEMA_VERSION),
         "__NETWORK_NAME__": NETWORK_NAME,
         "__CADDY_CONTAINER__": CADDY_CONTAINER,
@@ -203,6 +280,9 @@ def build_remote_script(spec: dict[str, Any] | None = None) -> str:
         "__D_SPEC_SHA__": desired["specSha256"],
         "__D_ENV_KEYS__": " ".join(f"'{item}'" for item in env_keys),
         "__D_ENV_VALUES__": " ".join(f"'{item}'" for item in env_values),
+        "__D_MATERIAL_NAMES__": " ".join(shlex.quote(x) for x in material_names),
+        "__D_MATERIAL_TARGETS__": " ".join(shlex.quote(x) for x in material_targets),
+        "__D_MATERIAL_EXPECTED__": " ".join(shlex.quote(x) for x in material_expected),
     }
     script = REMOTE_SCRIPT
     for placeholder, value in replacements.items():
@@ -224,7 +304,7 @@ def _parse_inventory(output: str) -> dict[str, Any]:
                 raise DeploymentKitError("Malformed or duplicate application inventory summary.")
             summary[parts[1]] = parts[2]
             continue
-        if parts[0] != "APP" or len(parts) != 15:
+        if parts[0] != "APP" or len(parts) not in (15, 17):
             raise DeploymentKitError("Malformed application inventory record.")
         try:
             port = int(parts[7])
@@ -258,6 +338,29 @@ def _parse_inventory(output: str) -> dict[str, Any]:
             "connectedToSharedNetwork": parts[13] == "true",
             "httpHealthy": parts[14] == "true",
         }
+        if len(parts) == 17:
+            if parts[15] not in {"true", "false"} or not parts[16]:
+                raise DeploymentKitError("Malformed remote material mount readiness.")
+            materials: list[dict[str, str]] = []
+            for encoded in parts[16].split(";"):
+                pieces = encoded.split("@")
+                if len(pieces) != 3 or re.fullmatch(r"[0-9]+:[0-9]+", pieces[2]) is None:
+                    raise DeploymentKitError("Malformed remote material inventory identity.")
+                materials.append({
+                    "name": pieces[0],
+                    "containerPath": pieces[1],
+                    "sourceIdentity": pieces[2],
+                })
+            normalized = _normalize_read_only_materials(
+                [(item["name"], item["containerPath"]) for item in materials],
+                data_path=None,
+            )
+            if [(item["name"], item["containerPath"]) for item in normalized] != [
+                (item["name"], item["containerPath"]) for item in materials
+            ]:
+                raise DeploymentKitError("Remote material inventory is unordered or conflicting.")
+            app["readOnlyMaterials"] = materials
+            app["materialMountsVerified"] = parts[15] == "true"
         apps.append(app)
     if set(summary) != {"appCount"}:
         raise DeploymentKitError("Application inventory omitted appCount.")
@@ -280,8 +383,9 @@ def _run_remote(
     *,
     spec: dict[str, Any] | None = None,
     expected_spec_sha: str = "",
+    expected_materials: dict[str, str] | None = None,
 ) -> str:
-    if action not in {"inventory", "deploy"}:
+    if action not in {"inventory", "deploy", "material-inspect"}:
         raise DeploymentKitError(f"Unsupported application-runtime action: {action}")
     args = [action]
     if action == "deploy":
@@ -293,7 +397,7 @@ def _run_remote(
     )
     completed = subprocess.run(
         command,
-        input=build_remote_script(spec).encode("utf-8"),
+        input=build_remote_script(spec, expected_materials=expected_materials).encode("utf-8"),
         check=False,
         capture_output=True,
     )
@@ -360,9 +464,10 @@ def plan_app_deploy(name: str, spec: dict[str, Any]) -> dict[str, Any]:
         and existing["containerRunning"]
         and existing["connectedToSharedNetwork"]
         and existing["httpHealthy"]
+        and existing.get("materialMountsVerified", True)
     ):
         raise DeploymentKitError("The exact application runtime spec is already deployed and healthy.")
-    return {
+    plan = {
         "targetName": name,
         "action": "deploy",
         "environment": spec["environment"],
@@ -385,6 +490,9 @@ def plan_app_deploy(name: str, spec: dict[str, Any]) -> dict[str, Any]:
         "expectedSpecSha256": existing["specSha256"] if existing is not None else None,
         "spec": spec,
     }
+    if spec.get("readOnlyMaterials"):
+        plan["readOnlyMaterialEvidence"] = _material_evidence_for_spec(name, spec)
+    return plan
 
 
 def deploy_write_phrase(plan: dict[str, Any]) -> str:
@@ -428,7 +536,7 @@ def render_locked_app_deploy_stage(
         "expectedSpecSha256",
         "spec",
     }
-    if not isinstance(plan, dict) or set(plan) != required or plan["action"] != "deploy":
+    if not isinstance(plan, dict) or set(plan) != required | ({"readOnlyMaterialEvidence"} if plan.get("spec", {}).get("readOnlyMaterials") else set()) or plan["action"] != "deploy":
         raise DeploymentKitError("Malformed application deployment plan.")
     if (plan["changeType"] != "update" or plan["retainsPreviousRelease"] is not True
             or not isinstance(plan["expectedSpecSha256"], str)
@@ -456,7 +564,8 @@ def render_locked_app_deploy_stage(
         )
     profile = load_profile(plan["targetName"])
     evidence = verify_access(profile)
-    script = build_remote_script(plan["spec"])
+    _verify_material_evidence(plan["targetName"], plan)
+    script = build_remote_script(plan["spec"], expected_materials=plan.get("readOnlyMaterialEvidence"))
     delimiter = "PROJECT_FORGE_APP_DEPLOY_STAGE_" + hashlib.sha256(script.encode()).hexdigest()[:24]
     if delimiter in script:
         raise DeploymentKitError("Unsafe application deployment script delimiter collision.")
@@ -495,7 +604,7 @@ def apply_app_deploy(plan: dict[str, Any]) -> dict[str, Any]:
         "expectedSpecSha256",
         "spec",
     }
-    if not isinstance(plan, dict) or set(plan) != required or plan["action"] != "deploy":
+    if not isinstance(plan, dict) or set(plan) != required | ({"readOnlyMaterialEvidence"} if plan.get("spec", {}).get("readOnlyMaterials") else set()) or plan["action"] != "deploy":
         raise DeploymentKitError("Malformed application deployment plan.")
 
     current = app_inventory(plan["targetName"])
@@ -507,6 +616,7 @@ def apply_app_deploy(plan: dict[str, Any]) -> dict[str, Any]:
     if platform["state"] != "ready":
         raise DeploymentKitError("Shared host platform is no longer ready; application deployment is blocked.")
 
+    _verify_material_evidence(plan["targetName"], plan)
     profile = load_profile(plan["targetName"])
     evidence = verify_access(profile)
     _run_remote(
@@ -515,6 +625,7 @@ def apply_app_deploy(plan: dict[str, Any]) -> dict[str, Any]:
         "deploy",
         spec=plan["spec"],
         expected_spec_sha=plan["expectedSpecSha256"] or "",
+        expected_materials=plan.get("readOnlyMaterialEvidence"),
     )
     final = app_inventory(plan["targetName"])
     deployed = _find_app(final, plan["appSlug"], plan["environment"])
@@ -526,6 +637,7 @@ def apply_app_deploy(plan: dict[str, Any]) -> dict[str, Any]:
         deployed["containerRunning"]
         and deployed["connectedToSharedNetwork"]
         and deployed["httpHealthy"]
+        and deployed.get("materialMountsVerified", True)
     ):
         raise DeploymentKitError("Application deployment completed but runtime readiness is not healthy.")
     final["mutated"] = True