@mriekki/project-forge 4.9.0 → 4.10.1

package/assets/components.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 2,
   "package": "@mriekki/project-forge",
-  "version": "4.9.0",
+  "version": "4.10.1",
   "defaultProfile": "greenfield-project",
   "profiles": {
     "greenfield-project": {
@@ -13,7 +13,7 @@
   },
   "components": {
     "core": {
-      "revision": "a78c2482f4f559ead8efbab6c25b4b05496db735",
+      "revision": "8796fd8dc22df8b64078e5b460e1008a8c7a5f7d",
       "version": "4.0.0",
       "distribution": "greenfield-workspace",
       "descriptor": "assets/core/distribution.json",
@@ -21,7 +21,7 @@
       "canonicalDescriptor": "distributions/greenfield-workspace.json"
     },
     "deployment": {
-      "revision": "fd2cf23fa9e3d4fa27e142ce3a963f51b39cba36",
+      "revision": "6b13a6e66218c067771311db1336c73229d23899",
       "distribution": "greenfield-project",
       "descriptor": "assets/deployment/distribution.json",
       "sourceRoot": "assets/generated/deployment",

package/assets/deployment/distribution.json

@@ -19,6 +19,7 @@
     {"source": "src/project_forge_deployment/cloudflare_api.py", "destination": "tools/project-forge-deployment/project_forge_deployment/cloudflare_api.py"},
     {"source": "src/project_forge_deployment/cloudflare_ingress.py", "destination": "tools/project-forge-deployment/project_forge_deployment/cloudflare_ingress.py"},
     {"source": "src/project_forge_deployment/cloudflare_ingress_remote.py", "destination": "tools/project-forge-deployment/project_forge_deployment/cloudflare_ingress_remote.py"},
+    {"source": "src/project_forge_deployment/cloudflare_route_apply.py", "destination": "tools/project-forge-deployment/project_forge_deployment/cloudflare_route_apply.py"},
     {"source": "src/project_forge_deployment/cli.py", "destination": "tools/project-forge-deployment/project_forge_deployment/cli.py"},
     {"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"},

package/assets/generated/ASSEMBLY.json

@@ -1,10 +1,10 @@
 {
   "schemaVersion": 2,
   "package": "@mriekki/project-forge",
-  "version": "4.9.0",
+  "version": "4.10.1",
   "components": {
     "core": {
-      "revision": "a78c2482f4f559ead8efbab6c25b4b05496db735",
+      "revision": "8796fd8dc22df8b64078e5b460e1008a8c7a5f7d",
       "version": "4.0.0",
       "distribution": "greenfield-workspace",
       "files": [
@@ -126,7 +126,7 @@
         {
           "source": "core/skills/tear-down/SKILL.md",
           "destination": ".github/skills/tear-down/SKILL.md",
-          "sha256": "7565b5600af2883abfc47bac29abfd056cfa81536c52408b07da82f696b335b8"
+          "sha256": "468314030c6033885c46aba50f54410928cbe44c74d73b998b88338fe495f3d9"
         },
         {
           "source": "core/skills/coach/SKILL.md",
@@ -326,7 +326,7 @@
       ]
     },
     "deployment": {
-      "revision": "fd2cf23fa9e3d4fa27e142ce3a963f51b39cba36",
+      "revision": "6b13a6e66218c067771311db1336c73229d23899",
       "distribution": "greenfield-project",
       "files": [
         {
@@ -407,7 +407,12 @@
         {
           "source": "src/project_forge_deployment/cloudflare_ingress_remote.py",
           "destination": "tools/project-forge-deployment/project_forge_deployment/cloudflare_ingress_remote.py",
-          "sha256": "38688e85654090dc7f4ab634eb3b5b6aedce9f3edb695f3d62bb09789214c86e"
+          "sha256": "35ac39b4f4538d4ff23f68982cc4b176782378cf03539fa51a228becbdfcf4d0"
+        },
+        {
+          "source": "src/project_forge_deployment/cloudflare_route_apply.py",
+          "destination": "tools/project-forge-deployment/project_forge_deployment/cloudflare_route_apply.py",
+          "sha256": "eea7a5b4322e0601db36d28cb0529522d6acc37c55dfc9a7b41d91518fe14cd4"
         },
         {
           "source": "src/project_forge_deployment/cli.py",
@@ -422,7 +427,7 @@
         {
           "source": "src/project_forge_deployment/entrypoint.py",
           "destination": "tools/project-forge-deployment/project_forge_deployment/entrypoint.py",
-          "sha256": "90d241bbbfb592c0b8e6368e13d3b3b8fb6c1e3f34c5fac9fe593df4e4a5cf1d"
+          "sha256": "c9dd332a68e923ef15a9f228e0666306c9692dd3ffe724b73160ce313f627ab6"
         },
         {
           "source": "src/project_forge_deployment/environment_cli.py",
@@ -462,7 +467,7 @@
         {
           "source": "src/project_forge_deployment/ingress_cli.py",
           "destination": "tools/project-forge-deployment/project_forge_deployment/ingress_cli.py",
-          "sha256": "c70b312aacceb9e6761eafa07a534fc41ce728b2b9aef130568b399367b2640c"
+          "sha256": "0e4088a17734f560c750528942fbd34d2464bcdd06d60467a9dc684a73fc18e1"
         },
         {
           "source": "src/project_forge_deployment/keys.py",
@@ -572,17 +577,17 @@
         {
           "source": "src/project_forge_deployment/teardown.py",
           "destination": "tools/project-forge-deployment/project_forge_deployment/teardown.py",
-          "sha256": "08215b8b5fa87ca8abf96f10f38aca0207840bd1b1faf4c2c53cb691caf20a72"
+          "sha256": "0c75bb1ec77218d1b6ee3f54a626556ee46f2de8e91d1e9afa87200bce39254e"
         },
         {
           "source": "src/project_forge_deployment/teardown_cli.py",
           "destination": "tools/project-forge-deployment/project_forge_deployment/teardown_cli.py",
-          "sha256": "214987895cde77648b5274042f1c21557046c3bf76224bfdd415ea34fec3d873"
+          "sha256": "5dbe92b1d5683824bbf3b4892f9099db2d68ad95c0a514bf73f7b596a62775be"
         },
         {
           "source": "src/project_forge_deployment/teardown_remote.py",
           "destination": "tools/project-forge-deployment/project_forge_deployment/teardown_remote.py",
-          "sha256": "ad764f5a67c43f81b4973dd5639b2c28b23ae883a85e5ae29efc14dad506e88e"
+          "sha256": "5a898ee8ce981c60839d12c63a776bf742e2c32bc409fbb29cdfd798cf9baa19"
         },
         {
           "source": "src/project_forge_deployment/topology_cli.py",

package/assets/generated/core/core/skills/tear-down/SKILL.md

@@ -1,27 +1,52 @@
 ---
 name: tear-down
-description: "Guided destructive cleanup for local state, one exact repository-defined named environment, or all explicitly configured Project environments. Preserves ownership boundaries and resolved Production-data authorization."
-argument-hint: "[local|<environment>|all]"
+description: "List target-owned Project environments and guide destructive cleanup for local state, one exact named environment, or all explicitly configured Project environments. Preserves ownership boundaries, shared Project Forge infrastructure, and separate Production/public-ingress authorization."
+argument-hint: "[list [<target>]|local|<environment>|all]"
 user-invocable: true
 disable-model-invocation: true
 ---
 
 # Tear Down
 
-`/tear-down` is the human-facing destructive cleanup workflow for repository-owned Project state.
+`/tear-down` is the human-facing inventory and destructive-cleanup workflow for Project-owned deployment state.
 
 Logical environment names are data-driven and are not limited to Staging/Production:
 
 ```text
+/tear-down list production
 /tear-down demo
 /tear-down qa
 /tear-down staging
 /tear-down prod-east
 ```
 
-The skill owns exact scope selection, read-only preflight, destructive preview, and Human-in-the-Loop authorization. Repository-provided deterministic tooling owns deletion mechanics.
+The skill owns target selection, exact scope selection, read-only inventory/preflight, destructive preview, and Human-in-the-Loop authorization. Deployment Kit deterministic tooling owns inventory and deletion mechanics.
 
-## 1. Resolve exact project topology
+## 0. List what is installed before destructive selection
+
+When the Builder asks what is deployed, what can be removed, or invokes `list`, use the Deployment Kit read-only target inventory:
+
+```text
+project-forge-deploy target inventory <target> --json
+```
+
+This is the canonical application-cleanup inventory. It correlates the target's managed runtime, trusted-LAN route, and managed public-ingress ownership into application/environment tear-down candidates while reporting the shared host platform separately.
+
+The command is intentionally independent of the consumer repository. If a consumer checkout or even its GitHub repository has already been deleted, the same installed/standalone Deployment Kit command may still inventory the target from host-owned metadata and user-scoped target access configuration.
+
+Inside a consumer repository, use the repository-provided Deployment Kit launcher when that is the installed contract. Detect the current platform/runtime and invoke the portable Python entrypoint or installed `project-forge-deploy`; do not assume PowerShell syntax or Windows-only paths. macOS/Linux shells and Windows/PowerShell must reach the same deterministic CLI semantics.
+
+Do not reconstruct inventory by ad-hoc `ssh`, `docker ps`, filesystem listing, or Cloudflare commands when Deployment Kit target inventory is available.
+
+If a public-ingress scope cannot be inferred from the application/environment name, pass only the exact additional scope established by repository topology or trusted operator evidence:
+
+```text
+--ingress-scope <scope>
+```
+
+Listing is read-only. It does not authorize later deletion.
+
+## 1. Resolve exact project topology when the repository exists
 
 Prefer:
 
@@ -37,8 +62,12 @@ If `demo` is configured, `/tear-down demo` means exactly `demo`. If `prod-east`
 
 Never guess a similar environment and never widen scope after failure.
 
+When the repository no longer exists, use target inventory only for target-owned application identity and resource ownership. Do not invent repository-only topology facts. In particular, if a non-literal custom environment's Production classification cannot be established from trusted evidence, stop before destructive authorization rather than weakening the Production-data gate.
+
 ## 2. Select exact destructive scope
 
+The destructive scope contract remains exactly `[local|<environment>|all]`; `list` is a separate read-only discovery mode and never becomes a destructive scope.
+
 ```text
 local
 <one exact repository-defined named environment>
@@ -47,13 +76,15 @@ all
 
 If no scope is named, present only scopes the repository actually supports; never silently default to a Production environment or `all`.
 
+For orphaned deployments where the consumer repository is unavailable, present only exact application/environment candidates returned by target inventory.
+
 `all` means only all explicitly configured scopes for this Project; it never means machine-wide cleanup.
 
 Selecting scope does not authorize deletion. Physical colocation never merges ownership: deleting `demo` must not remove `staging` or `prod-east` merely because they share hardware.
 
-If the requested name is absent from project topology, stop. Do not substitute another environment.
+If the requested name is absent from project topology or target inventory, stop. Do not substitute another environment.
 
-## 3. Resolve Production classification from the deletion set
+## 3. Resolve Production and public-ingress classification from the deletion set
 
 For each selected environment identify:
 
@@ -62,6 +93,8 @@ environment name
 purpose / Production classification
 placement / target
 repository/application identity
+trusted-LAN route
+managed public-ingress scope/hostname, when present
 ownership markers required by installed tooling
 ```
 
@@ -71,7 +104,13 @@ For current Deployment Kit consumers, custom Production names may be passed expl
 --production-environment prod-east
 ```
 
-Use actual installed help/version evidence. If the installed tool cannot preserve a custom Production classification, stop rather than downgrading the destructive gate.
+When target inventory reports an owned public route, preserve its exact environment-to-ingress-scope binding for cleanup, conceptually:
+
+```text
+--public-ingress-scope production=production
+```
+
+Use actual installed help/version evidence. If the installed tool cannot preserve a custom Production classification or exact public-ingress ownership, stop rather than downgrading the destructive gate.
 
 ## 4. Present an exact destructive preview
 
@@ -86,10 +125,17 @@ Selected environments:
   <name> → <placement/target> — <purpose/classification>
 
 Will remove:
-  <only tool-owned resources for exact selected scopes>
+  owned public hostname/DNS + tunnel rule, when selected
+  owned trusted-LAN route
+  owned application container/runtime
+  owned releases, evidence, persistent data, and backups
+  remote immutable image only when no other managed release/container still references it
 
 Will preserve:
-  <shared/unrelated environment and platform resources>
+  shared Project Forge Caddy/network/platform
+  shared Cloudflare tunnel/runtime
+  unrelated Projects/environments
+  remote images still referenced by another managed release/container
 ```
 
 Do not promise deletion of named/shared Docker volumes unless the installed deterministic contract proves exact ownership and explicitly includes them. Do not promise deletion of any shared/unrelated resource whose ownership cannot be proven.
@@ -108,33 +154,45 @@ whenever **any selected environment is Production-class**, require the stronger
 [PRODUCTION DATA DELETE]
 ```
 
+Whenever the reviewed deletion set includes an owned public-ingress route, also require the separate public-ingress removal authorization, conceptually:
+
+```text
+[PUBLIC INGRESS ROUTE REMOVE]
+```
+
 Resolve exact phrases from the installed tool/version. Do not tie the Production-data gate only to literal scope strings such as `production` or `all`; it depends on the actual resolved deletion set.
 
-A prior `/setup`, environment proof, `/deploy`, merge, CI, or other approval never authorizes destructive cleanup.
+A prior `/setup`, environment proof, `/deploy`, merge, CI, public-route registration, or other approval never authorizes destructive cleanup.
 
-If identity, selected environment set, classification, binding, ownership evidence, or deletion set changes after preview, require renewed review/authorization.
+If identity, selected environment set, classification, binding, ownership evidence, public-ingress scope, or deletion set changes after preview, require renewed review/authorization.
 
-## 6. Execute only repository-provided deterministic cleanup
+## 6. Execute only Deployment Kit deterministic cleanup
 
 After authorization, invoke only the approved tear-down command with exact named scopes/bindings. Do not improvise shell commands.
 
 For a generalized current Deployment Kit invocation, exact bindings may look conceptually like:
 
 ```text
---environment-target demo=<target>
 --environment-target staging=<target>
---environment-target prod-east=<target>
+--environment-target production=<target>
+--public-ingress-scope production=production
 --production-environment prod-east
 ```
 
-Use the installed contract rather than inventing flags for older versions.
+Use target inventory output and the installed contract rather than inventing flags for older versions.
 
-Never add machine-wide Docker prune, shared platform/network removal, unrelated environment cleanup, host reprovisioning, target rebinding, credential/trust deletion, or registry-package deletion unless a separate lifecycle operation explicitly owns and authorizes it.
+Public ingress must be removed before the trusted-LAN route/runtime so a public hostname is never deliberately left pointing at a removed origin. The shared Cloudflare tunnel/runtime is host infrastructure and must remain.
+
+Remote image cleanup is bounded: remove only the selected environment's immutable image when no other managed release metadata or container still references it. Never use Docker system/image/volume prune.
+
+Never add machine-wide Docker prune, shared platform/network removal, unrelated environment cleanup, host reprovisioning, target rebinding, credential/trust deletion, registry-package deletion, or shared Cloudflare tunnel deletion unless a separate lifecycle operation explicitly owns and authorizes it.
 
 If aggregate `all` cleanup stops partway, report completed and remaining scopes. Do not manually compensate by deleting the rest.
 
 ## 7. Verify and report outcome
 
-Use repository-provided status/evidence commands when available. Report only observed evidence: requested scope, exact environment names/targets processed, Production-class environments included, local state processed, removed versus already-absent resources, and any remaining scopes after a partial stop.
+Re-run target inventory after cleanup when available. Report only observed evidence: requested scope, exact environment names/targets processed, Production-class environments included, public routes removed/already absent, trusted-LAN routes removed/already absent, runtime/data removal, remote image removed/retained, local state processed, and any remaining scopes after a partial stop.
+
+Shared Project Forge platform state and unrelated application candidates should remain present and unchanged.
 
 When the installed deterministic contract is idempotent, already-absent owned resources should remain safe to re-check/re-run without broadening scope.

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

@@ -236,6 +236,7 @@ route_inventory() {
     printf 'SUMMARY\tscope\t%s\n' "$SCOPE"
     printf 'SUMMARY\tmanagedRouteCount\t%s\n' "$count"
     for path in "$ROUTE_ROOT"/*.route; do [[ -f "$path" ]] && emit_route "$path"; done
+    return 0
 }
 
 metadata_matches() {

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

@@ -0,0 +1,165 @@
+"""Safe public-route apply wrapper for Cloudflare provider normalization.
+
+Cloudflare currently adds ``warp-routing: {enabled: false}`` when returning a
+remotely managed tunnel configuration even when that provider default was not
+submitted.  Project Forge tolerates only that observed no-op normalization;
+all reviewed ingress rules and every other configuration value remain exact.
+"""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Any
+
+from . import cloudflare_api
+from . import cloudflare_ingress as ingress
+from .errors import DeploymentKitError
+from .profiles import load_profile
+from .ssh import verify_access
+
+_FINAL_VERIFICATION_ERRORS = {
+    "Public route registration returned without exact host ownership metadata.",
+    "Cloudflare tunnel configuration does not match the reviewed route plan after apply.",
+    "Cloudflare DNS record is missing after public-route apply.",
+}
+
+
+def _reviewed_config_matches(actual: Any, reviewed: Any) -> bool:
+    """Match reviewed config after removing only the observed safe provider default."""
+    if not isinstance(actual, dict) or not isinstance(reviewed, dict):
+        return False
+    normalized = deepcopy(actual)
+    if "warp-routing" not in reviewed and normalized.get("warp-routing") == {"enabled": False}:
+        normalized.pop("warp-routing")
+    return normalized == reviewed
+
+
+def _read_final_state(plan: dict[str, Any], *, api_token: str) -> dict[str, Any]:
+    name = plan["targetName"]
+    scope = plan["scope"]
+    spec = plan["route"]
+    host = ingress.cloudflare_ingress_status(name, scope)
+    inventory = ingress.cloudflare_route_inventory(name, scope)
+    route = ingress._find_route(inventory, spec["routeId"])
+    config = cloudflare_api.get_tunnel_configuration(api_token, host["accountId"], host["tunnelId"])
+    records = cloudflare_api.list_dns_records(api_token, host["zoneId"], name=spec["publicHostname"])
+    dns_error: str | None = None
+    try:
+        dns = ingress._exact_dns_record(records, spec=spec, tunnel_id=host["tunnelId"])
+    except DeploymentKitError as error:
+        dns = None
+        dns_error = str(error)
+    return {
+        "host": host,
+        "route": route,
+        "config": config,
+        "dns": dns,
+        "dnsError": dns_error,
+    }
+
+
+def _rollback_final_state(
+    plan: dict[str, Any],
+    state: dict[str, Any],
+    *,
+    api_token: str,
+) -> list[str]:
+    """Best-effort reverse only mutations that can still be attributed safely."""
+    errors: list[str] = []
+    host = state["host"]
+    spec = plan["route"]
+
+    if plan["dnsRecord"] is None:
+        dns = state["dns"]
+        if dns is not None:
+            try:
+                cloudflare_api.delete_dns_record(api_token, host["zoneId"], str(dns["id"]))
+            except Exception as error:  # pragma: no cover - provider failure detail only
+                errors.append(f"DNS rollback failed: {error}")
+        elif state["dnsError"] is not None:
+            errors.append("DNS rollback skipped because current DNS ownership is ambiguous.")
+
+    if plan["desiredTunnelConfig"] != plan["tunnelConfig"]:
+        current = state["config"]
+        if _reviewed_config_matches(current, plan["desiredTunnelConfig"]):
+            try:
+                cloudflare_api.update_tunnel_configuration(
+                    api_token,
+                    host["accountId"],
+                    host["tunnelId"],
+                    plan["tunnelConfig"],
+                )
+            except Exception as error:  # pragma: no cover - provider failure detail only
+                errors.append(f"tunnel configuration rollback failed: {error}")
+        elif not _reviewed_config_matches(current, plan["tunnelConfig"]):
+            errors.append(
+                "Tunnel configuration rollback skipped because current provider state cannot be safely attributed to this apply."
+            )
+
+    if plan["previousRoute"] is None and state["route"] == spec:
+        try:
+            profile = load_profile(plan["targetName"])
+            access = verify_access(profile)
+            ingress._run_remote(
+                profile,
+                access["address"],
+                "route-remove",
+                scope=plan["scope"],
+                spec=spec,
+            )
+        except Exception as error:  # pragma: no cover - remote failure detail only
+            errors.append(f"host route rollback failed: {error}")
+
+    return errors
+
+
+def apply_public_route(plan: dict[str, Any], *, api_token: str) -> dict[str, Any]:
+    """Apply a reviewed public route with bounded post-write recovery.
+
+    The underlying apply retains all pre-write stale-state checks and its write
+    rollback.  Recovery is entered only for errors that are emitted exclusively
+    by the final verification phase, so preflight failures can never be turned
+    into success by observing later provider state.
+    """
+    try:
+        return ingress.apply_public_route(plan, api_token=api_token)
+    except Exception as original_error:
+        if (
+            not isinstance(original_error, DeploymentKitError)
+            or str(original_error) not in _FINAL_VERIFICATION_ERRORS
+            or not isinstance(plan, dict)
+            or plan.get("action") != "register"
+        ):
+            raise
+        required = {
+            "targetName", "scope", "route", "previousRoute", "tunnelConfig",
+            "desiredTunnelConfig", "dnsRecord", "dnsMarker",
+        }
+        if not required.issubset(plan):
+            raise
+
+        try:
+            state = _read_final_state(plan, api_token=api_token)
+        except Exception:
+            raise original_error
+
+        route_ok = state["route"] == plan["route"]
+        config_ok = _reviewed_config_matches(state["config"], plan["desiredTunnelConfig"])
+        dns_ok = state["dns"] is not None
+        if route_ok and config_ok and dns_ok:
+            return {
+                "targetName": plan["targetName"],
+                "scope": plan["scope"],
+                "route": plan["route"],
+                "dnsRecordId": str(state["dns"]["id"]),
+                "publicUrl": f"https://{plan['route']['publicHostname']}",
+                "mutated": True,
+            }
+
+        rollback_errors = _rollback_final_state(plan, state, api_token=api_token)
+        if rollback_errors:
+            raise DeploymentKitError(
+                "Cloudflare public-route final verification failed and rollback was incomplete: "
+                + "; ".join(rollback_errors)
+            ) from original_error
+        raise original_error

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

@@ -1,23 +1,84 @@
-"""Top-level console entrypoint for Deployment Kit command groups."""
+"""Top-level console entrypoint for Deployment Kit command groups.
+
+Command groups are loaded lazily so an optional capability defect cannot prevent
+unrelated Deployment Kit commands from starting.
+"""
 
 from __future__ import annotations
 
 import sys
 
-from .access_cli import main as access_main
-from .app_cli import main as app_main
-from .cli import main as core_main
-from .environment_cli import main as environment_main
-from .ingress_cli import main as ingress_main
-from .local_cli import main as local_main
-from .registry_cli import main as registry_main
-from .sqlite_cli import main as sqlite_main
-from .teardown_cli import main as teardown_main
-from .topology_cli import main as topology_main
+
+def access_main(argv: list[str]) -> int:
+    from .access_cli import main
+
+    return main(argv)
+
+
+def app_main(argv: list[str]) -> int:
+    from .app_cli import main
+
+    return main(argv)
+
+
+def core_main(argv: list[str]) -> int:
+    from .cli import main
+
+    return main(argv)
+
+
+def environment_main(argv: list[str]) -> int:
+    from .environment_cli import main
+
+    return main(argv)
+
+
+def ingress_main(argv: list[str]) -> int:
+    from .ingress_cli import main
+
+    return main(argv)
+
+
+def local_main(argv: list[str]) -> int:
+    from .local_cli import main
+
+    return main(argv)
+
+
+def registry_main(argv: list[str]) -> int:
+    from .registry_cli import main
+
+    return main(argv)
+
+
+def sqlite_main(argv: list[str]) -> int:
+    from .sqlite_cli import main
+
+    return main(argv)
+
+
+def target_inventory_main(argv: list[str]) -> int:
+    from .teardown_cli import inventory_main
+
+    return inventory_main(argv)
+
+
+def teardown_main(argv: list[str]) -> int:
+    from .teardown_cli import main
+
+    return main(argv)
+
+
+def topology_main(argv: list[str]) -> int:
+    from .topology_cli import main
+
+    return main(argv)
 
 
 def main(argv: list[str] | None = None) -> int:
     args = list(sys.argv[1:] if argv is None else argv)
+    if len(args) >= 2 and args[0] == "target" and args[1] == "inventory":
+        return target_inventory_main(args[2:])
     if args and args[0] == "access":
         return access_main(args[1:])
     if args and args[0] == "app":
@@ -36,6 +97,8 @@ def main(argv: list[str] | None = None) -> int:
         return teardown_main(args[1:])
     if args and args[0] == "topology":
         return topology_main(args[1:])
+    if args[:2] in (["target", "--help"], ["target", "-h"]):
+        print("Additional command: inventory  Read app-owned tear-down candidates without writes")
     if not args or args == ["--help"] or args == ["-h"]:
         print("Command group: access  Read-only strict SSH target-access diagnosis")
         print("Command group: app  Remote immutable application runtime inventory/deployment")
@@ -46,4 +109,5 @@ def main(argv: list[str] | None = None) -> int:
         print("Command group: sqlite  SQLite persistence import/backup/migration/rollback checks")
         print("Command group: tear-down  Scoped destructive Project environment/local cleanup")
         print("Command group: topology  Project-owned logical environment binding")
+        print("Target command: inventory  Read app-owned tear-down candidates without writes")
     return core_main(args)

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

@@ -14,7 +14,6 @@ from .cloudflare_ingress import (
     PUBLIC_INGRESS_ROUTE_REMOVE_PHRASE,
     PUBLIC_INGRESS_ROUTE_WRITE_PHRASE,
     apply_cloudflare_ingress,
-    apply_public_route,
     apply_public_route_removal,
     cloudflare_ingress_doctor,
     cloudflare_ingress_status,
@@ -23,6 +22,7 @@ from .cloudflare_ingress import (
     plan_public_route,
     plan_public_route_removal,
 )
+from .cloudflare_route_apply import apply_public_route
 from .errors import DeploymentKitError
 
 

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

@@ -3,12 +3,23 @@
 from __future__ import annotations
 
 import json
+import os
 import re
 import shlex
 import shutil
 import subprocess
 from typing import Any, Iterable
 
+from .app_runtime import app_inventory
+from .box_platform import platform_status
+from .cloudflare_ingress import (
+    CLOUDFLARE_API_TOKEN_ENV,
+    PUBLIC_INGRESS_ROUTE_REMOVE_PHRASE,
+    apply_public_route_removal,
+    cloudflare_ingress_status,
+    cloudflare_route_inventory,
+    plan_public_route_removal,
+)
 from .errors import DeploymentKitError
 from .profiles import load_profile
 from .route_registry import apply_route_change, plan_route_removal, route_inventory
@@ -60,6 +71,24 @@ def parse_environment_targets(items: Iterable[str]) -> dict[str, str]:
     return dict(sorted(result.items()))
 
 
+def parse_environment_scopes(items: Iterable[str]) -> dict[str, str]:
+    result: dict[str, str] = {}
+    for item in items:
+        if not isinstance(item, str) or "=" not in item:
+            raise DeploymentKitError("public-ingress scope bindings must use environment=scope form.")
+        environment, scope = item.split("=", 1)
+        environment = _slug(environment, "environment")
+        if environment in RESERVED_SCOPES:
+            raise DeploymentKitError(f"{environment!r} is reserved and cannot be a remote environment name.")
+        scope = _slug(scope, "public ingress scope")
+        if scope in RESERVED_SCOPES:
+            raise DeploymentKitError(f"{scope!r} is reserved and cannot be a public ingress scope.")
+        if environment in result:
+            raise DeploymentKitError(f"Duplicate public-ingress scope binding: {environment}")
+        result[environment] = scope
+    return dict(sorted(result.items()))
+
+
 def _normalize_production_environments(items: Iterable[str]) -> set[str]:
     result = {"production"}
     for item in items:
@@ -78,6 +107,7 @@ def normalize_teardown_spec(
     environment_targets: dict[str, str] | Iterable[tuple[str, str]],
     local_package: str | None,
     production_environments: Iterable[str] = (),
+    public_ingress_scopes: dict[str, str] | Iterable[tuple[str, str]] = (),
 ) -> dict[str, Any]:
     scope = _slug(scope, "scope")
     pairs = environment_targets.items() if isinstance(environment_targets, dict) else environment_targets
@@ -92,6 +122,23 @@ def normalize_teardown_spec(
             raise DeploymentKitError(f"Duplicate environment target binding: {environment}")
         normalized_targets[environment] = target
 
+    ingress_pairs = (
+        public_ingress_scopes.items()
+        if isinstance(public_ingress_scopes, dict)
+        else public_ingress_scopes
+    )
+    normalized_ingress: dict[str, str] = {}
+    for environment, ingress_scope in ingress_pairs:
+        environment = _slug(environment, "environment")
+        ingress_scope = _slug(ingress_scope, "public ingress scope")
+        if environment not in normalized_targets:
+            raise DeploymentKitError(
+                f"public ingress scope binding {environment!r} has no matching environment target binding."
+            )
+        if environment in normalized_ingress:
+            raise DeploymentKitError(f"Duplicate public-ingress scope binding: {environment}")
+        normalized_ingress[environment] = ingress_scope
+
     if scope == "local":
         selected_targets: dict[str, str] = {}
     elif scope == "all":
@@ -107,15 +154,21 @@ def normalize_teardown_spec(
 
     production_set = _normalize_production_environments(production_environments)
     selected_production = sorted(set(selected_targets).intersection(production_set))
+    selected_ingress = {
+        environment: normalized_ingress[environment]
+        for environment in selected_targets
+        if environment in normalized_ingress
+    }
 
     return {
-        "schemaVersion": 2,
+        "schemaVersion": 3,
         "ownerRepo": _owner_repo(owner_repo),
         "appSlug": _slug(app_slug, "appSlug"),
         "scope": scope,
         "environmentTargets": selected_targets,
         "localPackage": package,
         "productionEnvironments": selected_production,
+        "publicIngressScopes": selected_ingress,
     }
 
 
@@ -124,6 +177,178 @@ def _find_route(inventory: dict[str, Any], app_slug: str, environment: str) -> d
     return next((item for item in inventory["managedRoutes"] if item["routeId"] == route_id), None)
 
 
+def _ensure_candidate(
+    candidates: dict[str, dict[str, Any]],
+    *,
+    owner_repo: str,
+    app_slug: str,
+    environment: str,
+    target_name: str,
+) -> dict[str, Any]:
+    route_id = f"{app_slug}--{environment}"
+    candidate = candidates.get(route_id)
+    if candidate is None:
+        candidate = {
+            "routeId": route_id,
+            "ownerRepo": owner_repo,
+            "appSlug": app_slug,
+            "environment": environment,
+            "targetName": target_name,
+            "runtime": None,
+            "trustedLanRoute": None,
+            "publicIngress": [],
+        }
+        candidates[route_id] = candidate
+        return candidate
+    if candidate["ownerRepo"] != owner_repo:
+        raise DeploymentKitError(
+            f"Target inventory ownership mismatch for {route_id}: "
+            f"{candidate['ownerRepo']} versus {owner_repo}."
+        )
+    return candidate
+
+
+def target_inventory(name: str, *, ingress_scopes: Iterable[str] = ()) -> dict[str, Any]:
+    """Read one target's shared platform and application-owned tear-down candidates."""
+    platform = platform_status(name)
+    apps_result = app_inventory(name)
+    lan_result = route_inventory(name)
+
+    candidates: dict[str, dict[str, Any]] = {}
+    inferred_scopes: set[str] = set()
+
+    for app in apps_result["applications"]:
+        candidate = _ensure_candidate(
+            candidates,
+            owner_repo=app["ownerRepo"],
+            app_slug=app["appSlug"],
+            environment=app["environment"],
+            target_name=name,
+        )
+        candidate["runtime"] = app
+        inferred_scopes.add(app["environment"])
+
+    for route in lan_result["managedRoutes"]:
+        candidate = _ensure_candidate(
+            candidates,
+            owner_repo=route["ownerRepo"],
+            app_slug=route["appSlug"],
+            environment=route["environment"],
+            target_name=name,
+        )
+        candidate["trustedLanRoute"] = route
+        inferred_scopes.add(route["environment"])
+
+    if isinstance(name, str) and _SLUG_RE.fullmatch(name):
+        inferred_scopes.add(name)
+    requested_scopes = {_slug(item, "public ingress scope") for item in ingress_scopes}
+    scopes = sorted(inferred_scopes | requested_scopes)
+
+    public_scopes: list[dict[str, Any]] = []
+    for scope in scopes:
+        status = cloudflare_ingress_status(name, scope)
+        routes: list[dict[str, Any]] = []
+        if status["markerPresent"]:
+            routes = cloudflare_route_inventory(name, scope)["managedRoutes"]
+            for route in routes:
+                candidate = _ensure_candidate(
+                    candidates,
+                    owner_repo=route["ownerRepo"],
+                    app_slug=route["appSlug"],
+                    environment=route["environment"],
+                    target_name=name,
+                )
+                candidate["publicIngress"].append({"scope": scope, **route})
+        public_scopes.append(
+            {
+                "scope": scope,
+                "state": status["state"],
+                "markerPresent": status["markerPresent"],
+                "managedRoutes": routes,
+            }
+        )
+
+    applications: list[dict[str, Any]] = []
+    for candidate in sorted(
+        candidates.values(),
+        key=lambda item: (item["appSlug"], item["environment"], item["ownerRepo"]),
+    ):
+        public_bindings = sorted(
+            {item["scope"] for item in candidate["publicIngress"]}
+        )
+        literal_production = candidate["environment"] == "production"
+        candidate["tearDown"] = {
+            "available": True,
+            "scope": candidate["environment"],
+            "environmentTarget": f"{candidate['environment']}={name}",
+            "publicIngressScopes": [
+                f"{candidate['environment']}={scope}" for scope in public_bindings
+            ],
+            "productionClassification": (
+                "production" if literal_production else "requires-trusted-evidence"
+            ),
+            "productionClassificationSource": (
+                "literal-environment-name" if literal_production else "not-encoded-in-target-inventory"
+            ),
+            "requiresProductionDataAuthorization": True if literal_production else None,
+            "requiresPublicIngressAuthorization": bool(public_bindings),
+        }
+        applications.append(candidate)
+
+    return {
+        "schemaVersion": 1,
+        "targetName": name,
+        "verifiedAddress": apps_result.get("verifiedAddress") or lan_result.get("verifiedAddress"),
+        "sharedPlatform": platform,
+        "applications": applications,
+        "publicIngressScopes": public_scopes,
+        "mutated": False,
+    }
+
+
+def _tear_down_public_ingress(
+    target: str,
+    scope: str,
+    owner_repo: str,
+    app_slug: str,
+    environment: str,
+) -> dict[str, Any]:
+    inventory = cloudflare_route_inventory(target, scope)
+    route = _find_route(inventory, app_slug, environment)
+    if route is None:
+        return {"state": "absent", "mutated": False, "scope": scope}
+    if (
+        route["ownerRepo"] != owner_repo
+        or route["appSlug"] != app_slug
+        or route["environment"] != environment
+    ):
+        raise DeploymentKitError(
+            f"Public route {app_slug}--{environment} ownership does not match the requested Project."
+        )
+    token = os.environ.get(CLOUDFLARE_API_TOKEN_ENV, "").strip()
+    if not token:
+        raise DeploymentKitError(
+            f"Cloudflare API authorization is required to remove owned public ingress. "
+            f"Set {CLOUDFLARE_API_TOKEN_ENV} in the current workstation process/secret boundary; "
+            "never put the token in the Project repository or command line."
+        )
+    plan = plan_public_route_removal(
+        target,
+        scope=scope,
+        owner_repo=owner_repo,
+        environment=environment,
+        app_slug=app_slug,
+        api_token=token,
+    )
+    result = apply_public_route_removal(plan, api_token=token)
+    return {
+        "state": "removed",
+        "mutated": bool(result.get("mutated")),
+        "scope": scope,
+        "publicHostname": route["publicHostname"],
+    }
+
+
 def _tear_down_route(target: str, owner_repo: str, app_slug: str, environment: str) -> dict[str, Any]:
     inventory = route_inventory(target)
     route = _find_route(inventory, app_slug, environment)
@@ -170,13 +395,18 @@ def _tear_down_remote_environment(
             "Remote Project tear-down failed: " + (stderr or stdout or f"exit {completed.returncode}")
         )
     parts = stdout.split("\t")
-    if len(parts) not in {4, 5} or parts[0] != "TEAR_DOWN" or parts[1] not in {"absent", "removed"}:
+    if len(parts) not in {4, 5, 7} or parts[0] != "TEAR_DOWN" or parts[1] not in {"absent", "removed"}:
         raise DeploymentKitError("Remote Project tear-down returned malformed evidence.")
     if parts[2] != app_slug or parts[3] != environment:
         raise DeploymentKitError("Remote Project tear-down returned mismatched app/environment evidence.")
     result: dict[str, Any] = {"state": parts[1], "mutated": parts[1] == "removed"}
-    if len(parts) == 5:
+    if len(parts) >= 5:
         result["containerName"] = parts[4]
+    if len(parts) == 7:
+        if parts[6] not in {"true", "false"}:
+            raise DeploymentKitError("Remote Project tear-down returned malformed image-removal evidence.")
+        result["images"] = [item for item in parts[5].split(",") if item]
+        result["allImagesRemoved"] = parts[6] == "true"
     return result
 
 
@@ -256,11 +486,21 @@ def tear_down_project(spec: dict[str, Any]) -> dict[str, Any]:
         environment_targets=(spec.get("environmentTargets") or {}).items(),
         local_package=spec.get("localPackage"),
         production_environments=spec.get("productionEnvironments") or (),
+        public_ingress_scopes=(spec.get("publicIngressScopes") or {}).items(),
     )
 
     environments: list[dict[str, Any]] = []
     mutated = False
     for environment, target in normalized["environmentTargets"].items():
+        public_ingress: dict[str, Any] = {"state": "not-selected", "mutated": False}
+        if environment in normalized["publicIngressScopes"]:
+            public_ingress = _tear_down_public_ingress(
+                target,
+                normalized["publicIngressScopes"][environment],
+                normalized["ownerRepo"],
+                normalized["appSlug"],
+                environment,
+            )
         route = _tear_down_route(target, normalized["ownerRepo"], normalized["appSlug"], environment)
         runtime = _tear_down_remote_environment(
             target,
@@ -268,11 +508,17 @@ def tear_down_project(spec: dict[str, Any]) -> dict[str, Any]:
             normalized["appSlug"],
             environment,
         )
-        mutated = mutated or route["mutated"] or runtime["mutated"]
+        mutated = (
+            mutated
+            or public_ingress["mutated"]
+            or route["mutated"]
+            or runtime["mutated"]
+        )
         environments.append(
             {
                 "environment": environment,
                 "targetName": target,
+                "publicIngress": public_ingress,
                 "route": route,
                 "runtimeAndPersistentData": runtime,
             }
@@ -284,7 +530,7 @@ def tear_down_project(spec: dict[str, Any]) -> dict[str, Any]:
         mutated = mutated or workstation["mutated"]
 
     return {
-        "schemaVersion": 2,
+        "schemaVersion": 3,
         "ownerRepo": normalized["ownerRepo"],
         "appSlug": normalized["appSlug"],
         "scope": normalized["scope"],
@@ -292,6 +538,8 @@ def tear_down_project(spec: dict[str, Any]) -> dict[str, Any]:
         "workstation": workstation,
         "productionEnvironments": normalized["productionEnvironments"],
         "productionDataIncluded": bool(normalized["productionEnvironments"]),
+        "publicIngressScopes": normalized["publicIngressScopes"],
+        "publicIngressIncluded": bool(normalized["publicIngressScopes"]),
         "mutated": mutated,
     }
 

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

@@ -3,15 +3,19 @@
 from __future__ import annotations
 
 import argparse
+import json
 import sys
 
 from .errors import DeploymentKitError
 from .teardown import (
     PRODUCTION_DATA_DELETE_PHRASE,
+    PUBLIC_INGRESS_ROUTE_REMOVE_PHRASE,
     TEAR_DOWN_WRITE_PHRASE,
     normalize_teardown_spec,
+    parse_environment_scopes,
     parse_environment_targets,
     render_teardown_summary,
+    target_inventory,
     tear_down_project,
 )
 
@@ -22,7 +26,7 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
         description=(
             "Remove one named Kit-managed environment, all explicitly bound environments, "
             "and/or exact-package local Docker state. Remote tear-down deletes persistent "
-            "application data for selected environments."
+            "application data for selected environments while preserving shared Project Forge platform state."
         ),
     )
     parser.add_argument(
@@ -38,6 +42,16 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
         metavar="ENV=TARGET",
         help="Explicit named environment-to-target binding; repeat as needed.",
     )
+    parser.add_argument(
+        "--public-ingress-scope",
+        action="append",
+        default=[],
+        metavar="ENV=SCOPE",
+        help=(
+            "Optional exact environment-to-public-ingress-scope binding discovered from target inventory; "
+            "repeat as needed. Selected public routes are removed before LAN/runtime cleanup."
+        ),
+    )
     parser.add_argument(
         "--production-environment",
         action="append",
@@ -66,34 +80,84 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
             f"{PRODUCTION_DATA_DELETE_PHRASE}"
         ),
     )
+    parser.add_argument(
+        "--public-ingress-authorization",
+        help=(
+            "Additional phrase required whenever selected environments include public ingress cleanup: "
+            f"{PUBLIC_INGRESS_ROUTE_REMOVE_PHRASE}"
+        ),
+    )
     return parser.parse_args(argv)
 
 
 def _preview(spec: dict[str, object]) -> dict[str, object]:
     production = bool(spec["productionEnvironments"])
+    public_ingress = bool(spec["publicIngressScopes"])
     return {
-        "schemaVersion": 2,
+        "schemaVersion": 3,
         "ownerRepo": spec["ownerRepo"],
         "appSlug": spec["appSlug"],
         "scope": spec["scope"],
         "environmentTargets": spec["environmentTargets"],
+        "publicIngressScopes": spec["publicIngressScopes"],
         "localPackage": spec["localPackage"],
         "productionEnvironments": spec["productionEnvironments"],
         "destructive": True,
         "deletesPersistentData": bool(spec["environmentTargets"]),
         "deletesProductionData": production,
+        "removesPublicIngress": public_ingress,
+        "removesUnreferencedRemoteImages": bool(spec["environmentTargets"]),
         "preservesSharedPlatform": True,
+        "preservesSharedPublicIngressRuntime": True,
         "preservesUnrelatedProjects": True,
         "deletesGhcrPackage": False,
         "requiredAuthorization": TEAR_DOWN_WRITE_PHRASE,
         "requiredProductionDataAuthorization": PRODUCTION_DATA_DELETE_PHRASE if production else None,
+        "requiredPublicIngressAuthorization": (
+            PUBLIC_INGRESS_ROUTE_REMOVE_PHRASE if public_ingress else None
+        ),
     }
 
 
+def inventory_main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="project-forge-deploy target inventory",
+        description=(
+            "Read shared platform state plus application-owned resources that are valid tear-down candidates "
+            "on one target. This command is read-only and does not require a consumer repository."
+        ),
+    )
+    parser.add_argument("name", help="Logical Project Forge target profile")
+    parser.add_argument(
+        "--ingress-scope",
+        action="append",
+        default=[],
+        metavar="SCOPE",
+        help=(
+            "Additional public-ingress scope to inspect when it cannot be inferred from managed application "
+            "or LAN-route environment names; repeat as needed."
+        ),
+    )
+    parser.add_argument("--json", action="store_true")
+    try:
+        args = parser.parse_args(argv)
+        result = target_inventory(args.name, ingress_scopes=args.ingress_scope)
+        if args.json:
+            print(json.dumps(result, indent=2, sort_keys=True))
+        else:
+            print("TARGET INVENTORY")
+            print(json.dumps(result, indent=2, sort_keys=True))
+        return 0
+    except DeploymentKitError as exc:
+        print(f"ERROR: {exc}", file=sys.stderr)
+        return 2
+
+
 def main(argv: list[str] | None = None) -> int:
     try:
         args = parse_args(argv)
         bindings = parse_environment_targets(args.environment_target)
+        public_bindings = parse_environment_scopes(args.public_ingress_scope)
         spec = normalize_teardown_spec(
             owner_repo=args.owner_repo,
             app_slug=args.app_slug,
@@ -101,6 +165,7 @@ def main(argv: list[str] | None = None) -> int:
             environment_targets=bindings,
             local_package=args.local_package,
             production_environments=args.production_environment,
+            public_ingress_scopes=public_bindings,
         )
         preview = _preview(spec)
 
@@ -110,7 +175,12 @@ def main(argv: list[str] | None = None) -> int:
             needs_production
             and args.production_data_authorization != PRODUCTION_DATA_DELETE_PHRASE
         )
-        if missing_general or missing_production:
+        needs_public_ingress = bool(spec["publicIngressScopes"])
+        missing_public_ingress = (
+            needs_public_ingress
+            and args.public_ingress_authorization != PUBLIC_INGRESS_ROUTE_REMOVE_PHRASE
+        )
+        if missing_general or missing_production or missing_public_ingress:
             print("PROJECT TEAR-DOWN PREVIEW")
             print(render_teardown_summary(preview))
             if missing_general:
@@ -124,6 +194,12 @@ def main(argv: list[str] | None = None) -> int:
                     f"--production-data-authorization {PRODUCTION_DATA_DELETE_PHRASE!r}",
                     file=sys.stderr,
                 )
+            if missing_public_ingress:
+                print(
+                    "ERROR: public-ingress removal requires "
+                    f"--public-ingress-authorization {PUBLIC_INGRESS_ROUTE_REMOVE_PHRASE!r}",
+                    file=sys.stderr,
+                )
             return 2
 
         result = tear_down_project(spec)

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

@@ -10,6 +10,7 @@ ENVIRONMENT="$3"
 
 valid_slug() { [[ "$1" =~ ^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$ ]]; }
 valid_repo() { [[ "$1" =~ ^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$ ]]; }
+valid_image() { [[ "$1" =~ ^[A-Za-z0-9][A-Za-z0-9._/:+-]*@sha256:[0-9a-f]{64}$ ]]; }
 meta_value() {
     local path="$1" key="$2"
     [[ -f "$path" && ! -L "$path" ]] || return 1
@@ -22,6 +23,13 @@ assert_owned_marker() {
        "$(meta_value "$path" APP_SLUG || true)" == "$APP" && \
        "$(meta_value "$path" ENVIRONMENT || true)" == "$ENVIRONMENT" ]]
 }
+append_unique_image() {
+    local value="$1" existing
+    for existing in "${IMAGES[@]:-}"; do
+        [[ "$existing" == "$value" ]] && return 0
+    done
+    IMAGES+=("$value")
+}
 
 valid_repo "$OWNER" || { echo "Invalid owner repository." >&2; exit 20; }
 valid_slug "$APP" || { echo "Invalid application slug." >&2; exit 20; }
@@ -60,6 +68,23 @@ if [[ "$HAS_PERSISTENCE" == true ]] && ! assert_owned_marker "$PERSISTENCE"; the
 fi
 
 CONTAINER=""
+IMAGES=()
+if [[ -d "$ROOT/releases" && ! -L "$ROOT/releases" ]]; then
+    while IFS= read -r release_file; do
+        [[ -f "$release_file" && ! -L "$release_file" ]] || continue
+        assert_owned_marker "$release_file" || {
+            echo "Managed release ownership does not match selected environment: $release_file" >&2
+            exit 23
+        }
+        image="$(meta_value "$release_file" IMAGE || true)"
+        valid_image "$image" || {
+            echo "Managed release contains an invalid immutable image reference: $release_file" >&2
+            exit 23
+        }
+        append_unique_image "$image"
+    done < <(find "$ROOT/releases" -mindepth 2 -maxdepth 2 -type f -name release.env -print 2>/dev/null || true)
+fi
+
 if [[ "$HAS_STATE" == true ]]; then
     CURRENT_RELEASE="$(meta_value "$STATE" CURRENT_RELEASE || true)"
     [[ -n "$CURRENT_RELEASE" && "$CURRENT_RELEASE" != */* && "$CURRENT_RELEASE" != *..* ]] || {
@@ -96,5 +121,37 @@ if [[ -d "$APP_DIR" ]] && ! find "$APP_DIR" -mindepth 1 -print -quit | grep -q .
     rmdir "$APP_DIR"
 fi
 
-printf 'TEAR_DOWN\tremoved\t%s\t%s\t%s\n' "$APP" "$ENVIRONMENT" "$CONTAINER"
+RETAINED_IMAGE=false
+for IMAGE in "${IMAGES[@]:-}"; do
+    [[ -n "$IMAGE" ]] || continue
+    IMAGE_REFERENCED_ELSEWHERE=false
+    while IFS= read -r candidate; do
+        [[ -f "$candidate" && ! -L "$candidate" ]] || continue
+        if [[ "$(meta_value "$candidate" IMAGE || true)" == "$IMAGE" ]]; then
+            IMAGE_REFERENCED_ELSEWHERE=true
+            break
+        fi
+    done < <(find "$APP_ROOT" -mindepth 5 -maxdepth 5 -type f -name release.env -print 2>/dev/null || true)
+
+    if [[ "$IMAGE_REFERENCED_ELSEWHERE" == true ]] || \
+       docker ps -a --filter "ancestor=$IMAGE" --format '{{.ID}}' | grep -q .; then
+        RETAINED_IMAGE=true
+        continue
+    fi
+    if docker image inspect "$IMAGE" >/dev/null 2>&1; then
+        if ! docker image rm "$IMAGE" >/dev/null 2>&1; then
+            RETAINED_IMAGE=true
+        fi
+    fi
+done
+
+IMAGES_CSV=""
+if [[ ${#IMAGES[@]} -gt 0 ]]; then
+    IMAGES_CSV="$(IFS=,; echo "${IMAGES[*]}")"
+fi
+ALL_IMAGES_REMOVED=true
+[[ "$RETAINED_IMAGE" == true ]] && ALL_IMAGES_REMOVED=false
+
+printf 'TEAR_DOWN\tremoved\t%s\t%s\t%s\t%s\t%s\n' \
+    "$APP" "$ENVIRONMENT" "$CONTAINER" "$IMAGES_CSV" "$ALL_IMAGES_REMOVED"
 '''

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mriekki/project-forge",
-  "version": "4.9.0",
+  "version": "4.10.1",
   "description": "Public consumer distribution and updater for Project Forge engineering assets.",
   "type": "module",
   "bin": {