@mriekki/project-forge 4.3.0 → 4.4.0

package/assets/components.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "package": "@mriekki/project-forge",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "defaultProfile": "greenfield-project",
   "profiles": {
     "greenfield-project": {
@@ -14,7 +14,7 @@
   "components": {
     "core": {
       "repository": "mriekki/project-forge-core",
-      "commit": "c35a42d4a87e59b3729797a9a2aace8499a93953",
+      "commit": "45139179c3d10ebd89702ac3aedec231364d8a34",
       "version": "4.0.0",
       "distribution": "greenfield-workspace",
       "descriptor": "assets/core/distribution.json",
@@ -23,7 +23,7 @@
     },
     "deployment": {
       "repository": "mriekki/project-forge-deployment-kit",
-      "commit": "e5fe3333cad04714d714445866639680378eb23d",
+      "commit": "eb157c8ae2c638ae1cd08bf27446d430835adc80",
       "distribution": "greenfield-project",
       "descriptor": "assets/deployment/distribution.json",
       "sourceRoot": "assets/generated/deployment",

package/assets/deployment/distribution.json

@@ -7,6 +7,7 @@
     {"source": "src/project_forge_deployment/__init__.py", "destination": "tools/project-forge-deployment/project_forge_deployment/__init__.py"},
     {"source": "src/project_forge_deployment/__main__.py", "destination": "tools/project-forge-deployment/project_forge_deployment/__main__.py"},
     {"source": "src/project_forge_deployment/app_cli.py", "destination": "tools/project-forge-deployment/project_forge_deployment/app_cli.py"},
+    {"source": "src/project_forge_deployment/app_deployment.py", "destination": "tools/project-forge-deployment/project_forge_deployment/app_deployment.py"},
     {"source": "src/project_forge_deployment/app_runtime.py", "destination": "tools/project-forge-deployment/project_forge_deployment/app_runtime.py"},
     {"source": "src/project_forge_deployment/app_runtime_remote.py", "destination": "tools/project-forge-deployment/project_forge_deployment/app_runtime_remote.py"},
     {"source": "src/project_forge_deployment/app_runtime_workstation.py", "destination": "tools/project-forge-deployment/project_forge_deployment/app_runtime_workstation.py"},
@@ -17,6 +18,7 @@
     {"source": "src/project_forge_deployment/doctor.py", "destination": "tools/project-forge-deployment/project_forge_deployment/doctor.py"},
     {"source": "src/project_forge_deployment/entrypoint.py", "destination": "tools/project-forge-deployment/project_forge_deployment/entrypoint.py"},
     {"source": "src/project_forge_deployment/environment_cli.py", "destination": "tools/project-forge-deployment/project_forge_deployment/environment_cli.py"},
+    {"source": "src/project_forge_deployment/environment_isolation.py", "destination": "tools/project-forge-deployment/project_forge_deployment/environment_isolation.py"},
     {"source": "src/project_forge_deployment/environment_probe.py", "destination": "tools/project-forge-deployment/project_forge_deployment/environment_probe.py"},
     {"source": "src/project_forge_deployment/environment_setup.py", "destination": "tools/project-forge-deployment/project_forge_deployment/environment_setup.py"},
     {"source": "src/project_forge_deployment/errors.py", "destination": "tools/project-forge-deployment/project_forge_deployment/errors.py"},

package/assets/generated/ASSEMBLY.json

@@ -1,11 +1,11 @@
 {
   "schemaVersion": 1,
   "package": "@mriekki/project-forge",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "components": {
     "core": {
       "repository": "mriekki/project-forge-core",
-      "commit": "c35a42d4a87e59b3729797a9a2aace8499a93953",
+      "commit": "45139179c3d10ebd89702ac3aedec231364d8a34",
       "version": "4.0.0",
       "distribution": "greenfield-workspace",
       "files": [
@@ -117,12 +117,12 @@
         {
           "source": "core/skills/deployment-readiness/SKILL.md",
           "destination": ".github/skills/deployment-readiness/SKILL.md",
-          "sha256": "82eaf37f8acc4e3d69871a02ad38ab9bf94caccaa0b3a40784dbb622621e112c"
+          "sha256": "33be75e856b1b16378bb2a456d8418f8ae0b03edee75fb826d8f7ef3824d2f6a"
         },
         {
           "source": "core/skills/deploy/SKILL.md",
           "destination": ".github/skills/deploy/SKILL.md",
-          "sha256": "8296d5cdd166dc5e0125df5d8ebc83d901a04f71caad8563ec67e9d02761955a"
+          "sha256": "21b8209bc756ef2981f9e44f19ee80e79c1c5c7d5be4c03c9b528fdadd7b8eca"
         },
         {
           "source": "core/skills/tear-down/SKILL.md",
@@ -172,7 +172,7 @@
         {
           "source": "core/process/DEPLOYMENT_ENABLEMENT.md",
           "destination": "docs/process/DEPLOYMENT_ENABLEMENT.md",
-          "sha256": "fa4f0bf3929d7d07b0061191232d39a7d03ae5e1e334e2aeafd27bad83b845fc"
+          "sha256": "f45b84f64975f5f90f639ed1f4f8709d0153d48d109198764c0ec13218956188"
         },
         {
           "source": "core/process/HUMAN_GATES.md",
@@ -328,7 +328,7 @@
     },
     "deployment": {
       "repository": "mriekki/project-forge-deployment-kit",
-      "commit": "e5fe3333cad04714d714445866639680378eb23d",
+      "commit": "eb157c8ae2c638ae1cd08bf27446d430835adc80",
       "distribution": "greenfield-project",
       "files": [
         {
@@ -349,7 +349,12 @@
         {
           "source": "src/project_forge_deployment/app_cli.py",
           "destination": "tools/project-forge-deployment/project_forge_deployment/app_cli.py",
-          "sha256": "405c5b4ceb08885b3f789dad5af5bacc5ccd6913b73a6304f562229f29196338"
+          "sha256": "9bf8eb7337c5b506311bf718de71b9a2c9ac445eb94cb7dfdeb63a09e5f0f899"
+        },
+        {
+          "source": "src/project_forge_deployment/app_deployment.py",
+          "destination": "tools/project-forge-deployment/project_forge_deployment/app_deployment.py",
+          "sha256": "e58158e48c9fbd51b51f7af90f2dd178987ad3936e44507523cfc41b96fcd9f9"
         },
         {
           "source": "src/project_forge_deployment/app_runtime.py",
@@ -399,17 +404,22 @@
         {
           "source": "src/project_forge_deployment/environment_cli.py",
           "destination": "tools/project-forge-deployment/project_forge_deployment/environment_cli.py",
-          "sha256": "13d41913fd91ad2461bc28e1af0343dd81ba34141c0db8b30f20d89423b64582"
+          "sha256": "ff4883a491dc4b4fab4e4c2afbb2eb3f65ddce6ae7ff22df7ab355ded5cc4f6b"
+        },
+        {
+          "source": "src/project_forge_deployment/environment_isolation.py",
+          "destination": "tools/project-forge-deployment/project_forge_deployment/environment_isolation.py",
+          "sha256": "aa2f380c7cbf474084375460c9d9168390c608a6566559eab778764ad5cf094d"
         },
         {
           "source": "src/project_forge_deployment/environment_probe.py",
           "destination": "tools/project-forge-deployment/project_forge_deployment/environment_probe.py",
-          "sha256": "4e9a49a7cf0427dcdef1e28f955297569ec8cd0ee9d071404ef876e3ce036313"
+          "sha256": "0a7b7a939fa38172abf85a036e2e8e9e97fa2c890f63a2e4d9304b4d62ebfa2d"
         },
         {
           "source": "src/project_forge_deployment/environment_setup.py",
           "destination": "tools/project-forge-deployment/project_forge_deployment/environment_setup.py",
-          "sha256": "a79919da8655a6c42fded3224373f6381d15c8c68869b70c31d6edb7702fd348"
+          "sha256": "47ce6af4ab3b03c441725ec8cc1b356212ef7a1706635fe191affd959b09a5f5"
         },
         {
           "source": "src/project_forge_deployment/errors.py",

package/assets/generated/core/core/process/DEPLOYMENT_ENABLEMENT.md

@@ -78,6 +78,24 @@ If existing configuration is present, show known facts for confirmation. If part
 
 Remote probing requires explicit read-only authorization. Address discovery never substitutes for cryptographic host identity. Unknown/changed SSH identity fails closed.
 
+### Real application isolation readiness
+
+For supported remote application deployment, readiness should use the repository-distributed Deployment Kit launcher rather than infer collision safety from prose:
+
+```text
+tools/project-forge-deployment/project-forge-deploy.py app isolation ... --require-clear --json
+```
+
+The read-only check should be built from the exact known application footprint: target binding, owner repository, exact logical environment, resolved Production classification, app slug, container name, runtime port, persistence mode, optional SQLite database file, and intended route hostnames when applicable.
+
+The deterministic result may prove the current managed application footprint is non-colliding across ownership, runtime/container identity, route hostnames/upstream ownership, SQLite identity, persistence root, and per-app/per-environment lock identity. It may also report colocated sibling environments and a shared physical failure domain.
+
+A clear result is pre-deploy evidence only. It does not authorize application, route, persistence, migration, Production, or destructive writes. A blocked result means readiness must stop before the real application write gate and surface the structured conflict evidence.
+
+If installed package tooling lacks the required isolation capability, require a Project Forge capability/update path rather than reconstructing equivalent checks from model knowledge.
+
+When available, retain the isolation evidence fingerprint for human review. `/deploy` must still use the deterministic planner and current-state revalidation before mutation; a readiness fingerprint is not a durable write authorization.
+
 ## Deferred readiness
 
 A deferred placement is intentional configuration state:
@@ -108,6 +126,8 @@ failure domain. This may fit Project cost/learning goals, but it does not
 demonstrate host-level Production isolation.
 ```
 
+A clear application isolation preflight confirms only the currently requested Deployment Kit-managed footprint is non-colliding. It does not demonstrate host-level Production isolation.
+
 Production backup/recovery/security/deploy/destructive gates remain stronger regardless of colocation.
 
 ## Readiness cadence
@@ -118,6 +138,7 @@ select environment
 → inspect placement-relevant local state
 → show/confirm known facts
 → authorize relevant read-only verification
+→ run deterministic application isolation preflight when supported
 → repair only missing prerequisites under explicit write gates
 → ENVIRONMENT READY TO DEPLOY
 → /deploy <environment>
@@ -133,6 +154,8 @@ Readiness does **not** hide application deployment inside setup.
 
 Application runtime deployment, release-specific migration, route/port publication, live health/readiness, smoke validation, and release-specific evidence belong to `/deploy` when the installed adapter defines them.
 
+The application isolation preflight is a remote read-only inspection and does not itself authorize any later write.
+
 ## Pre-deploy versus post-deploy evidence
 
 Readiness proves only facts that can exist before deployment, such as:
@@ -142,6 +165,7 @@ Readiness proves only facts that can exist before deployment, such as:
 - local Docker readiness or verified remote target/identity depending on placement;
 - target OS/runtime when applicable;
 - artifact identity/access;
+- deterministic application isolation/collision evidence when supported;
 - route/port ownership availability;
 - persistence/backup/migration prerequisites;
 - deployment lock/recovery capability;
@@ -163,4 +187,4 @@ Once ready:
 /deploy <environment>
 ```
 
-`/deploy` verifies current topology/target/artifact evidence, presents the exact installed-tool authorization gate, delegates deterministic mechanics, and verifies placement-relevant live evidence.
+`/deploy` verifies current topology/target/artifact evidence, presents the exact installed-tool authorization gate, delegates deterministic mechanics, requires current isolation evidence when the installed adapter defines it, and verifies placement-relevant live evidence.

package/assets/generated/core/core/skills/deploy/SKILL.md

@@ -44,7 +44,7 @@ Read only what is needed, including when present:
 - `PROJECT_FORGE_BASELINE.json`;
 - `DEPLOYMENT_BASELINE.json`;
 - project topology and approved deployment/release requirements;
-- `/deployment-readiness` evidence;
+- `/deployment-readiness` evidence, including deterministic application isolation evidence when supported;
 - fresh setup-time environment-proof evidence for this workstation;
 - established application deployment facts.
 
@@ -60,6 +60,8 @@ When a fresh setup-time proof already demonstrated target access, platform readi
 
 Proof does not establish the real application's image/release, persistence/migration contract, route/exposure, secrets, health contract, or release policy.
 
+A prior readiness isolation fingerprint is review evidence only. It does not authorize deployment and does not replace the deterministic deployment planner's current isolation revalidation.
+
 ## 3. First real deployment asks only unresolved application questions
 
 The first real `/deploy <environment>` after environment proof may need a small application-specific completion step. Ask only material unknowns not already answered by project evidence, such as:
@@ -102,6 +104,8 @@ exact image acquired/built locally
 
 Do not copy a developer GitHub PAT/GHCR credential to the target as normal deployment behavior.
 
+For installed Deployment Kit versions that expose real application isolation planning, require that capability rather than reconstructing collision checks from model knowledge. If the installed package lacks the capability required by current Core policy, stop with a Project Forge update/capability requirement before requesting the application write authorization.
+
 ### Managed service
 
 Use only an installed repository/catalog provider adapter. If none exists, stop with `CATALOG GAP / PLANNED` rather than constructing provider commands from general knowledge.
@@ -137,6 +141,12 @@ optional backup/safety check
 → deployment evidence capture
 ```
 
+For the standard remote Deployment Kit path, pass the intended application footprint needed by the installed planner's isolation contract, including exact target, owner repository, environment, Production classification, app slug, container name, runtime port, persistence mode, optional SQLite database file, and intended route hostnames when applicable.
+
+When the deterministic application plan exposes reviewed isolation evidence (for example `isolationReview`), require a clear state and retain its evidence fingerprint for the human preview. A blocked plan is not deployable. Do not edit names/ports/routes/persistence identities automatically to make a blocked plan pass.
+
+The deterministic deployment tool owns the final current-state recheck immediately before mutation. Core must not substitute a stale readiness fingerprint or prose-only reasoning for that revalidation.
+
 Do not smuggle infrastructure provisioning, target/provider rebinding, destructive restore, or environment tear-down into the application plan.
 
 ## 7. Preserve exact authorization contracts
@@ -154,14 +164,16 @@ For Production-class environments also show `[PRODUCTION WRITE]` consequence vis
 
 Resolve the exact phrase from the installed tool/version. Do not assume an example phrase when the installed contract differs.
 
-Authorization applies only to the exact environment, resolved classification, placement/target/provider, artifact, reviewed plan, and evidence shown. Material changes require renewed review/authorization.
+Authorization applies only to the exact environment, resolved classification, placement/target/provider, artifact, reviewed plan, current isolation evidence, and evidence shown. Material changes require renewed review/authorization.
 
 ## 8. Preview and execute only the approved contract
 
-Before mutation, show concise non-secret evidence such as exact environment, purpose, placement, target/provider when applicable, proof freshness, immutable application artifact, persistence/migration, exposure/route, planned operations, and exact required authorization phrase.
+Before mutation, show concise non-secret evidence such as exact environment, purpose, placement, target/provider when applicable, proof freshness, immutable application artifact, persistence/migration, exposure/route, application isolation state/fingerprint when exposed, shared failure-domain note when relevant, planned operations, and exact required authorization phrase.
 
 After authorization, invoke only the repository-provided deterministic launcher. Never redirect to another environment/host/provider, weaken trust/exposure, force through lock contention, or invent recovery writes.
 
+The deterministic launcher must revalidate current isolation immediately before real application mutation when the installed contract provides that capability. If current isolation changed or became blocked after review, stop and create/review a fresh plan rather than continuing under the old authorization.
+
 Existing per-app/per-environment locks are normal concurrency protection when another workstation is deploying the same environment.
 
 ## 9. Validate live evidence

package/assets/generated/core/core/skills/deployment-readiness/SKILL.md

@@ -129,6 +129,43 @@ Before asking questions, inspect existing non-secret profile/target evidence. Cl
 
 Only after explicit `[REMOTE READ ONLY]` authorization under the installed/repository contract may new remote checks occur. Never scan/select another host or weaken host-key verification merely to get a green result.
 
+#### Real application isolation preflight
+
+For a supported remote application deployment, prefer the repository-distributed launcher:
+
+```text
+tools/project-forge-deployment/project-forge-deploy.py
+```
+
+Inspect installed help/version evidence before relying on a specific subcommand. When the installed contract exposes `app isolation`, use that deterministic read-only capability before declaring the application footprint ready. Do not reconstruct equivalent collision logic from model knowledge.
+
+Build the check from exact project/topology/application evidence only:
+
+```text
+app isolation <target>
+--owner-repo <owner/repository>
+--environment <exact logical environment>
+--app-slug <application slug>
+--container-name <managed container name>
+--runtime-port <container-scoped runtime port>
+--persistence-mode <none|directory>
+[--database-file <SQLite file when applicable>]
+[--route-hostname <intended hostname> ...]
+[--production when resolved purpose/classification is Production]
+--require-clear
+--json
+```
+
+Pass `--production` for custom Production names such as `prod-east`; never downgrade Production policy because the literal environment name differs.
+
+The isolation check is remote read-only evidence. A clear result may establish that the requested Project/environment footprint does not collide with current Deployment Kit-managed application ownership, container identity, route hostnames/upstream ownership, SQLite identity, persistence root, or deployment-lock identity. It may also report a shared physical failure domain and sibling logical environments.
+
+A blocked result or nonzero `--require-clear` outcome means the environment is **not ready to deploy**. Surface the structured collision codes/evidence and stop before any application write gate. Do not auto-rename the environment, container, route, database, target, or app merely to obtain a clear result.
+
+If current installed tooling does not expose the required isolation capability, report an installed-capability / Project Forge update requirement. Do not silently fall back to prose-only collision reasoning.
+
+Keep the returned isolation `evidenceSha256` with readiness evidence when available. It is review evidence, not a reusable write authorization; `/deploy` and the deterministic deployment tool must re-evaluate current state before mutation.
+
 ### C. Managed-service placement
 
 Use only a repository/catalog-provided provider adapter. If none exists, report:
@@ -155,6 +192,8 @@ Do not mark workspace readiness failed. Route to `/setup <environment>` or `/set
 
 Multiple logical environments may share physical failure domains, but they remain independently targetable and independently authorized. If environments share physical failure, state it explicitly.
 
+A clear application isolation preflight means the current Deployment Kit-managed footprint is non-colliding; it does **not** demonstrate host-level Production isolation.
+
 Colocation does not demonstrate host-level Production isolation. Never infer readiness for one logical environment from another merely because they share hardware.
 
 ## 5. State-driven cadence
@@ -166,6 +205,7 @@ select exact project-defined environment
 → read current topology
 → reuse fresh environment-proof evidence when valid
 → rediscover placement-relevant local state
+→ verify current application isolation when the installed adapter supports it
 → verify/repair only missing prerequisites under exact gates
 → ENVIRONMENT READY TO DEPLOY
 → /deploy <environment>
@@ -195,11 +235,13 @@ A missing prerequisite is not authorization to change it. Use the repository/too
 
 Do not hide the real application deployment inside readiness. Readiness may rely on the disposable setup-time proof, but it must not start/replace the real project runtime, register the final application route, perform release-specific migration, or claim project-release smoke validation.
 
+The application isolation preflight itself is read-only and does not authorize later deployment, route, persistence, migration, Production, or destructive writes.
+
 ## 8. Pre-deploy versus post-deploy evidence
 
 Readiness asks whether `/deploy <name>` can safely perform the real application deployment now.
 
-Pre-deploy evidence may include topology, adapter availability, binding, local/remote identity and access, target platform, fresh proof evidence, artifact policy, route/port availability, persistence/backup/migration prerequisites, lock/recovery capability, and Production-specific safeguards.
+Pre-deploy evidence may include topology, adapter availability, binding, local/remote identity and access, target platform, fresh proof evidence, artifact policy, deterministic application isolation/collision evidence, route/port availability, persistence/backup/migration prerequisites, lock/recovery capability, and Production-specific safeguards.
 
 Do not require first-deployment live route, deployed-release identity, application health, or smoke evidence before the application has ever been deployed. Those are post-deploy validation evidence owned by `/deploy`.
 
@@ -221,6 +263,8 @@ Purpose: <purpose>
 Placement: <...>
 Binding: VERIFIED / LOCAL / provider-specific
 This-workstation environment proof: PROVEN / NOT REQUIRED / NOT AVAILABLE
+Application isolation: CLEAR / NOT APPLICABLE
+Isolation evidence: <evidenceSha256 when exposed by installed tooling>
 Platform prerequisites: READY
 Application-specific prerequisites: READY / <remaining items>
 Security blockers: NONE

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

@@ -7,16 +7,19 @@ import json
 import sys
 from typing import Any
 
+from .app_deployment import (
+    app_isolation_check,
+    apply_app_deploy,
+    apply_app_deploy_from_workstation,
+    plan_app_deploy,
+)
 from .app_runtime import (
     APP_DEPLOY_WRITE_PHRASE,
     PRODUCTION_APP_DEPLOY_WRITE_PHRASE,
     app_inventory,
-    apply_app_deploy,
     deploy_write_phrase,
     normalize_app_spec,
-    plan_app_deploy,
 )
-from .app_runtime_workstation import apply_app_deploy_from_workstation
 from .errors import DeploymentKitError
 from .sqlite_adapter import assert_app_spec_matches_persistence
 
@@ -53,6 +56,35 @@ def _confirm(args: argparse.Namespace, phrase: str, action: str) -> None:
         raise DeploymentKitError(f"{action.capitalize()} was not authorized.")
 
 
+def _add_isolation_footprint(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("name")
+    parser.add_argument("--owner-repo", required=True)
+    parser.add_argument("--environment", required=True)
+    parser.add_argument(
+        "--production",
+        action="store_true",
+        help="Classify this named environment as Production even when its name is not literally 'production'",
+    )
+    parser.add_argument("--app-slug", required=True)
+    parser.add_argument("--container-name", required=True)
+    parser.add_argument("--runtime-port", type=int, required=True)
+    parser.add_argument(
+        "--persistence-mode",
+        choices=("none", "directory"),
+        required=True,
+    )
+    parser.add_argument(
+        "--database-file",
+        help="Optional intended SQLite database file used only for read-only collision/isolation checks",
+    )
+    parser.add_argument(
+        "--route-hostname",
+        action="append",
+        default=[],
+        help="Optional intended route hostname used only for read-only collision/isolation checks; repeat as needed",
+    )
+
+
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(prog="project-forge-deploy app")
     sub = parser.add_subparsers(dest="command", required=True)
@@ -64,29 +96,26 @@ def build_parser() -> argparse.ArgumentParser:
     inventory.add_argument("name")
     inventory.add_argument("--json", action="store_true")
 
+    isolation = sub.add_parser(
+        "isolation",
+        help="Read current managed ownership/runtime/route/persistence isolation for an application footprint",
+    )
+    _add_isolation_footprint(isolation)
+    isolation.add_argument(
+        "--require-clear",
+        action="store_true",
+        help="Exit nonzero when the read-only isolation result is blocked",
+    )
+    isolation.add_argument("--json", action="store_true")
+
     deploy = sub.add_parser(
         "deploy",
         help="Deploy one immutable application runtime without modifying routes",
     )
-    deploy.add_argument("name")
-    deploy.add_argument("--owner-repo", required=True)
-    deploy.add_argument("--environment", required=True)
-    deploy.add_argument(
-        "--production",
-        action="store_true",
-        help="Classify this named environment as Production even when its name is not literally 'production'",
-    )
-    deploy.add_argument("--app-slug", required=True)
-    deploy.add_argument("--container-name", required=True)
+    _add_isolation_footprint(deploy)
     deploy.add_argument("--image", required=True)
-    deploy.add_argument("--runtime-port", type=int, required=True)
     deploy.add_argument("--health-path", required=True)
     deploy.add_argument("--run-as", required=True)
-    deploy.add_argument(
-        "--persistence-mode",
-        choices=("none", "directory"),
-        required=True,
-    )
     deploy.add_argument("--data-container-path")
     deploy.add_argument(
         "--env",
@@ -115,6 +144,23 @@ def main(argv: list[str] | None = None) -> int:
             _print(app_inventory(args.name), as_json=args.json)
             return 0
 
+        production_classified = args.production or args.environment == "production"
+        if args.command == "isolation":
+            result = app_isolation_check(
+                args.name,
+                owner_repo=args.owner_repo,
+                environment=args.environment,
+                production=production_classified,
+                app_slug=args.app_slug,
+                container_name=args.container_name,
+                runtime_port=args.runtime_port,
+                persistence_mode=args.persistence_mode,
+                database_file=args.database_file,
+                route_hostnames=args.route_hostname,
+            )
+            _print(result, as_json=args.json)
+            return 2 if args.require_clear and result["state"] != "clear" else 0
+
         spec = normalize_app_spec(
             owner_repo=args.owner_repo,
             environment=args.environment,
@@ -129,10 +175,15 @@ def main(argv: list[str] | None = None) -> int:
             environment_variables=_parse_env(args.env),
         )
         assert_app_spec_matches_persistence(args.name, spec)
-        plan = plan_app_deploy(args.name, spec)
+        plan = plan_app_deploy(
+            args.name,
+            spec,
+            production=production_classified,
+            database_file=args.database_file,
+            route_hostnames=args.route_hostname,
+        )
         plan_view = {key: value for key, value in plan.items() if key != "spec"}
         plan_view["imageSource"] = args.image_source
-        production_classified = args.production or plan["environment"] == "production"
         plan_view["productionClassified"] = production_classified
         if args.image_source == "workstation":
             plan_view["targetRegistryCredentialRequired"] = False