@josephyan/qingflow-app-user-mcp 0.2.0-beta.1 → 0.2.0-beta.10

package/src/qingflow_mcp/builder_facade/service.py

@@ -4,10 +4,12 @@ from copy import deepcopy
 from dataclasses import dataclass
 import json
 import os
+import re
 import tempfile
 from typing import Any
 from uuid import uuid4
 
+from ..backend_client import BackendRequestContext
 from ..errors import QingflowApiError
 from ..json_types import JSONObject
 from ..solution.build_assembly_store import BuildAssemblyStore, default_artifacts, default_manifest
@@ -134,6 +136,75 @@ class AiBuilderFacade:
             "match_mode": "exact",
         }
 
+    def package_create(self, *, profile: str, package_name: str) -> JSONObject:
+        requested = str(package_name or "").strip()
+        normalized_args = {"package_name": requested}
+        if not requested:
+            return _failed(
+                "PACKAGE_NAME_REQUIRED",
+                "package_name is required",
+                normalized_args=normalized_args,
+                suggested_next_call=None,
+            )
+        existing = self.package_resolve(profile=profile, package_name=requested)
+        if existing.get("status") == "success":
+            return {
+                "status": "success",
+                "error_code": None,
+                "recoverable": False,
+                "message": "package already exists",
+                "normalized_args": normalized_args,
+                "missing_fields": [],
+                "allowed_values": {},
+                "details": {},
+                "request_id": None,
+                "suggested_next_call": None,
+                "noop": True,
+                "verification": {"existing_package_reused": True},
+                "tag_id": existing.get("tag_id"),
+                "tag_name": existing.get("tag_name"),
+            }
+        if existing.get("error_code") == "AMBIGUOUS_PACKAGE":
+            return existing
+        try:
+            created = self.packages.package_create(profile=profile, payload={"tagName": requested})
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "PACKAGE_CREATE_FAILED",
+                api_error,
+                normalized_args=normalized_args,
+                details={"package_name": requested},
+                suggested_next_call={"tool_name": "package_create", "arguments": {"profile": profile, "package_name": requested}},
+            )
+        result = created.get("result") if isinstance(created.get("result"), dict) else {}
+        tag_id = _coerce_positive_int(result.get("tagId"))
+        tag_name = str(result.get("tagName") or requested).strip() or requested
+        if tag_id is None:
+            resolved = self.package_resolve(profile=profile, package_name=requested)
+            if resolved.get("status") == "success":
+                tag_id = _coerce_positive_int(resolved.get("tag_id"))
+                tag_name = str(resolved.get("tag_name") or tag_name)
+        verified = tag_id is not None
+        return {
+            "status": "success" if verified else "partial_success",
+            "error_code": None,
+            "recoverable": False,
+            "message": "created package" if verified else "created package but could not verify tag id",
+            "normalized_args": normalized_args,
+            "missing_fields": [],
+            "allowed_values": {},
+            "details": {},
+            "request_id": None,
+            "suggested_next_call": None
+            if verified
+            else {"tool_name": "package_resolve", "arguments": {"profile": profile, "package_name": requested}},
+            "noop": False,
+            "verification": {"tag_id_verified": verified},
+            "tag_id": tag_id,
+            "tag_name": tag_name,
+        }
+
     def package_list(self, *, profile: str, trial_status: str = "all") -> JSONObject:
         listed = self.packages.package_list(profile=profile, trial_status=trial_status, include_raw=False)
         return {
@@ -209,6 +280,115 @@ class AiBuilderFacade:
             "attached": attached,
         }
 
+    def app_release_edit_lock_if_mine(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        lock_owner_email: str = "",
+        lock_owner_name: str = "",
+    ) -> JSONObject:
+        normalized_args = {
+            "app_key": app_key,
+            "lock_owner_email": lock_owner_email,
+            "lock_owner_name": lock_owner_name,
+        }
+        session_profile = self.apps.sessions.get_profile(profile)
+        if session_profile is None:
+            return _failed(
+                "AUTH_REQUIRED",
+                "auth profile is required before releasing an app edit lock",
+                normalized_args=normalized_args,
+                recoverable=False,
+                suggested_next_call={"tool_name": "auth_whoami", "arguments": {"profile": profile}},
+            )
+        identity = self._resolve_current_user_identity(profile=profile)
+        current_email = str(identity.get("email") or "").strip().lower()
+        current_name = str(identity.get("nick_name") or "").strip()
+        requested_owner_email = str(lock_owner_email or "").strip().lower()
+        requested_owner_name = str(lock_owner_name or "").strip()
+        if not requested_owner_email and not requested_owner_name:
+            return _failed(
+                "EDIT_LOCK_OWNER_UNKNOWN",
+                "lock owner could not be verified; refuse to release edit lock blindly",
+                normalized_args=normalized_args,
+                recoverable=False,
+                details={
+                    "current_user_email": identity.get("email"),
+                    "current_user_name": identity.get("nick_name"),
+                },
+                suggested_next_call=None,
+            )
+        owner_matches = True
+        if requested_owner_email:
+            owner_matches = bool(current_email) and current_email == requested_owner_email
+        elif requested_owner_name:
+            owner_matches = bool(current_name) and current_name == requested_owner_name
+        if not owner_matches:
+            return _failed(
+                "EDIT_LOCK_HELD_BY_OTHER_USER",
+                "edit lock is owned by another user; refusing to release it",
+                normalized_args=normalized_args,
+                recoverable=False,
+                details={
+                    "lock_owner_email": requested_owner_email or None,
+                    "lock_owner_name": requested_owner_name or None,
+                    "current_user_email": identity.get("email"),
+                    "current_user_name": identity.get("nick_name"),
+                },
+                suggested_next_call=None,
+            )
+        try:
+            version_result = self.apps.app_get_edit_version_no(profile=profile, app_key=app_key).get("result") or {}
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "EDIT_LOCK_RELEASE_FAILED",
+                api_error,
+                normalized_args=normalized_args,
+                details={"app_key": app_key},
+                suggested_next_call={"tool_name": "app_read_summary", "arguments": {"profile": profile, "app_key": app_key}},
+            )
+        edit_version_no = _coerce_positive_int(version_result.get("editVersionNo") or version_result.get("versionNo")) or 1
+        try:
+            self.apps.app_edit_finished(profile=profile, app_key=app_key, payload={"editVersionNo": edit_version_no})
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "EDIT_LOCK_RELEASE_FAILED",
+                api_error,
+                normalized_args=normalized_args,
+                details={
+                    "app_key": app_key,
+                    "edit_version_no": edit_version_no,
+                    "lock_owner_email": requested_owner_email or None,
+                    "lock_owner_name": requested_owner_name or None,
+                },
+                suggested_next_call={"tool_name": "app_release_edit_lock_if_mine", "arguments": {"profile": profile, **normalized_args}},
+            )
+        return {
+            "status": "success",
+            "error_code": None,
+            "recoverable": False,
+            "message": "released app edit lock owned by current user",
+            "normalized_args": normalized_args,
+            "missing_fields": [],
+            "allowed_values": {},
+            "details": {
+                "lock_owner_email": requested_owner_email or None,
+                "lock_owner_name": requested_owner_name or None,
+                "current_user_email": identity.get("email"),
+                "current_user_name": identity.get("nick_name"),
+                "edit_version_no": edit_version_no,
+            },
+            "request_id": None,
+            "suggested_next_call": {"tool_name": "app_read_summary", "arguments": {"profile": profile, "app_key": app_key}},
+            "noop": False,
+            "verification": {"released": True},
+            "app_key": app_key,
+            "released": True,
+        }
+
     def app_resolve(
         self,
         *,
@@ -220,8 +400,14 @@ class AiBuilderFacade:
         if app_key:
             try:
                 base = self.apps.app_get_base(profile=profile, app_key=app_key, include_raw=True)
-            except RuntimeError as exc:
-                return _failed("APP_NOT_FOUND", f"failed to resolve app_key '{app_key}'", details={"error": str(exc)})
+            except (QingflowApiError, RuntimeError) as exc:
+                api_error = _coerce_api_error(exc)
+                return _failed_from_api_error(
+                    "APP_NOT_FOUND" if api_error.http_status == 404 else "APP_RESOLVE_FAILED",
+                    api_error,
+                    details={"app_key": app_key},
+                    suggested_next_call={"tool_name": "app_read_summary", "arguments": {"profile": profile, "app_key": app_key}},
+                )
             result = base.get("result") if isinstance(base.get("result"), dict) else {}
             return {
                 "status": "success",
@@ -298,8 +484,30 @@ class AiBuilderFacade:
         }
 
     def app_read_summary(self, *, profile: str, app_key: str) -> JSONObject:
-        state = self._load_app_state(profile=profile, app_key=app_key)
+        try:
+            state = self._load_base_schema_state(profile=profile, app_key=app_key)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "APP_READ_FAILED",
+                api_error,
+                normalized_args={"app_key": app_key},
+                details={"app_key": app_key},
+                suggested_next_call={"tool_name": "app_resolve", "arguments": {"profile": profile, "app_key": app_key}},
+            )
+        views, views_unavailable = self._load_views_result(profile=profile, app_key=app_key, tolerate_404=True)
+        workflow, workflow_unavailable = self._load_workflow_result(profile=profile, app_key=app_key, tolerate_404=True)
         parsed = state["parsed"]
+        verification_hints = _build_verification_hints(
+            tag_ids=_coerce_int_list(state["base"].get("tagIds")),
+            fields=parsed["fields"],
+            layout=parsed["layout"],
+            views=_summarize_views(views),
+        )
+        if views_unavailable:
+            verification_hints.append("views_read_unavailable")
+        if workflow_unavailable:
+            verification_hints.append("workflow_read_unavailable")
         response = AppReadSummaryResponse(
             app_key=app_key,
             title=state["base"].get("formTitle"),
@@ -307,14 +515,9 @@ class AiBuilderFacade:
             publish_status=state["base"].get("appPublishStatus"),
             field_count=len(parsed["fields"]),
             layout_section_count=len(parsed["layout"].get("sections", [])),
-            view_count=len(_summarize_views(state["views"])),
-            workflow_enabled=bool(state["workflow"]),
-            verification_hints=_build_verification_hints(
-                tag_ids=_coerce_int_list(state["base"].get("tagIds")),
-                fields=parsed["fields"],
-                layout=parsed["layout"],
-                views=_summarize_views(state["views"]),
-            ),
+            view_count=len(_summarize_views(views)),
+            workflow_enabled=bool(workflow),
+            verification_hints=verification_hints,
         )
         return {
             "status": "success",
@@ -333,7 +536,17 @@ class AiBuilderFacade:
         }
 
     def app_read_fields(self, *, profile: str, app_key: str) -> JSONObject:
-        state = self._load_app_state(profile=profile, app_key=app_key)
+        try:
+            state = self._load_base_schema_state(profile=profile, app_key=app_key)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "FIELDS_READ_FAILED",
+                api_error,
+                normalized_args={"app_key": app_key},
+                details={"app_key": app_key},
+                suggested_next_call={"tool_name": "app_read_summary", "arguments": {"profile": profile, "app_key": app_key}},
+            )
         parsed = state["parsed"]
         response = AppFieldsReadResponse(
             app_key=app_key,
@@ -367,7 +580,17 @@ class AiBuilderFacade:
         }
 
     def app_read_layout_summary(self, *, profile: str, app_key: str) -> JSONObject:
-        state = self._load_app_state(profile=profile, app_key=app_key)
+        try:
+            state = self._load_base_schema_state(profile=profile, app_key=app_key)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "LAYOUT_READ_FAILED",
+                api_error,
+                normalized_args={"app_key": app_key},
+                details={"app_key": app_key},
+                suggested_next_call={"tool_name": "app_read_summary", "arguments": {"profile": profile, "app_key": app_key}},
+            )
         parsed = state["parsed"]
         layout = parsed["layout"]
         response = AppLayoutReadResponse(
@@ -393,10 +616,20 @@ class AiBuilderFacade:
         }
 
     def app_read_views_summary(self, *, profile: str, app_key: str) -> JSONObject:
-        state = self._load_app_state(profile=profile, app_key=app_key)
+        try:
+            views, _ = self._load_views_result(profile=profile, app_key=app_key, tolerate_404=False)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "VIEWS_READ_FAILED",
+                api_error,
+                normalized_args={"app_key": app_key},
+                details={"app_key": app_key},
+                suggested_next_call={"tool_name": "app_read_summary", "arguments": {"profile": profile, "app_key": app_key}},
+            )
         response = AppViewsReadResponse(
             app_key=app_key,
-            views=_summarize_views(state["views"]),
+            views=_summarize_views(views),
         )
         return {
             "status": "success",
@@ -415,11 +648,21 @@ class AiBuilderFacade:
         }
 
     def app_read_flow_summary(self, *, profile: str, app_key: str) -> JSONObject:
-        state = self._load_app_state(profile=profile, app_key=app_key)
+        try:
+            workflow, workflow_unavailable = self._load_workflow_result(profile=profile, app_key=app_key, tolerate_404=True)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "FLOW_READ_FAILED",
+                api_error,
+                normalized_args={"app_key": app_key},
+                details={"app_key": app_key},
+                suggested_next_call={"tool_name": "app_read_summary", "arguments": {"profile": profile, "app_key": app_key}},
+            )
         response = AppFlowReadResponse(
             app_key=app_key,
-            enabled=bool(state["workflow"]),
-            nodes=_summarize_workflow_nodes(state["workflow"]),
+            enabled=bool(workflow),
+            nodes=_summarize_workflow_nodes(workflow),
             transitions=[],
         )
         return {
@@ -434,7 +677,7 @@ class AiBuilderFacade:
             "request_id": None,
             "suggested_next_call": None,
             "noop": False,
-            "verification": {"app_exists": True},
+            "verification": {"app_exists": True, "workflow_read_unavailable": workflow_unavailable},
             **response.model_dump(mode="json"),
         }
 
@@ -452,7 +695,11 @@ class AiBuilderFacade:
             return target
         current_fields: list[dict[str, Any]] = []
         if not bool(target.get("would_create")):
-            current_fields = self.app_read_fields(profile=profile, app_key=str(target["app_key"])).get("fields", [])
+            fields_result = self.app_read_fields(profile=profile, app_key=str(target["app_key"]))
+            if fields_result.get("status") == "failed":
+                fields_result.setdefault("normalized_args", normalized_args)
+                return fields_result
+            current_fields = fields_result.get("fields", [])
         current_by_name = {str(field.get("name") or ""): field for field in current_fields}
         blocking_issues: list[dict[str, Any]] = []
         preview_added: list[str] = []
@@ -510,8 +757,12 @@ class AiBuilderFacade:
 
     def app_layout_plan(self, *, profile: str, request: LayoutPlanRequest) -> JSONObject:
         read_fields = self.app_read_fields(profile=profile, app_key=request.app_key)
+        if read_fields.get("status") == "failed":
+            return read_fields
         current_names = [str(field.get("name") or "") for field in read_fields.get("fields", []) if field.get("name")]
         current_layout = self.app_read_layout_summary(profile=profile, app_key=request.app_key)
+        if current_layout.get("status") == "failed":
+            return current_layout
         requested_sections = [section.model_dump(mode="json") for section in request.sections]
         if request.preset is not None:
             requested_sections = _build_layout_preset_sections(preset=request.preset, field_names=current_names)
@@ -574,7 +825,10 @@ class AiBuilderFacade:
         transitions = [transition.model_dump(mode="json", by_alias=True) for transition in request.transitions]
         if request.preset is not None:
             nodes, transitions = _build_flow_preset(request.preset)
-        current_fields = self.app_read_fields(profile=profile, app_key=request.app_key).get("fields", [])
+        fields_result = self.app_read_fields(profile=profile, app_key=request.app_key)
+        if fields_result.get("status") == "failed":
+            return fields_result
+        current_fields = fields_result.get("fields", [])
         status_field_present = _infer_status_field_id(current_fields) is not None
         node_types = {str(node.get("type") or "") for node in nodes}
         if ("approve" in node_types or request.preset in {FlowPreset.basic_approval, FlowPreset.basic_fill_then_approve}) and not status_field_present:
@@ -644,7 +898,10 @@ class AiBuilderFacade:
         }
 
     def app_views_plan(self, *, profile: str, request: ViewsPlanRequest) -> JSONObject:
-        current_fields = self.app_read_fields(profile=profile, app_key=request.app_key).get("fields", [])
+        fields_result = self.app_read_fields(profile=profile, app_key=request.app_key)
+        if fields_result.get("status") == "failed":
+            return fields_result
+        current_fields = fields_result.get("fields", [])
         field_names = {str(field.get("name") or "") for field in current_fields}
         upsert_views = [view.model_dump(mode="json") for view in request.upsert_views]
         if request.preset is not None:
@@ -728,8 +985,9 @@ class AiBuilderFacade:
         profile: str,
         app_key: str = "",
         package_tag_id: int | None = None,
-        app_title: str = "",
+        app_name: str = "",
         create_if_missing: bool = False,
+        publish: bool = True,
         add_fields: list[FieldPatch],
         update_fields: list[FieldUpdatePatch],
         remove_fields: list[FieldRemovePatch],
@@ -737,8 +995,9 @@ class AiBuilderFacade:
         normalized_args = {
             "app_key": app_key,
             "package_tag_id": package_tag_id,
-            "app_title": app_title,
+            "app_name": app_name,
             "create_if_missing": create_if_missing,
+            "publish": publish,
             "add_fields": [patch.model_dump(mode="json") for patch in add_fields],
             "update_fields": [patch.model_dump(mode="json") for patch in update_fields],
             "remove_fields": [patch.model_dump(mode="json") for patch in remove_fields],
@@ -746,27 +1005,36 @@ class AiBuilderFacade:
         resolved = self._resolve_or_create_target_app(
             profile=profile,
             app_key=app_key,
-            app_title=app_title,
+            app_name=app_name,
             package_tag_id=package_tag_id,
             create_if_missing=create_if_missing,
         )
         if resolved.get("status") == "failed":
+            if not isinstance(resolved.get("normalized_args"), dict) or not resolved.get("normalized_args"):
+                resolved["normalized_args"] = normalized_args
             return resolved
         target = ResolvedApp(
             app_key=str(resolved["app_key"]),
             app_name=str(resolved["app_name"]),
             tag_ids=_coerce_int_list(resolved.get("tag_ids")),
         )
-        schema = self.apps.app_get_form_schema(
-            profile=profile,
-            app_key=target.app_key,
-            form_type=1,
-            being_draft=True,
-            being_apply=None,
-            audit_node_id=None,
-            include_raw=True,
-        )
-        schema_result = schema.get("result") if isinstance(schema.get("result"), dict) else {}
+        schema_readback_delayed = False
+        try:
+            schema_result, _schema_source = self._read_schema_with_fallback(profile=profile, app_key=target.app_key)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            if not bool(resolved.get("created")) or api_error.http_status != 404:
+                return _failed_from_api_error(
+                    "SCHEMA_READBACK_FAILED",
+                    api_error,
+                    normalized_args=normalized_args,
+                    allowed_values={"field_types": [item.value for item in PublicFieldType]},
+                    details={"app_key": target.app_key},
+                    suggested_next_call={"tool_name": "app_read_summary", "arguments": {"profile": profile, "app_key": target.app_key}},
+                )
+            schema_result = _empty_schema_result(target.app_name)
+            _schema_source = "synthetic_new_app"
+            schema_readback_delayed = True
         parsed = _parse_schema(schema_result)
         current_fields = parsed["fields"]
         layout = parsed["layout"]
@@ -831,7 +1099,7 @@ class AiBuilderFacade:
         if not added and not updated and not removed and not bool(resolved.get("created")):
             tag_ids_after = _coerce_int_list((self.apps.app_get_base(profile=profile, app_key=target.app_key, include_raw=True).get("result") or {}).get("tagIds"))
             package_attached = None if package_tag_id is None else package_tag_id in tag_ids_after
-            return {
+            response = {
                 "status": "success",
                 "error_code": None,
                 "recoverable": False,
@@ -851,6 +1119,7 @@ class AiBuilderFacade:
                 "tag_ids_after": tag_ids_after,
                 "package_attached": package_attached,
             }
+            return self._append_publish_result(profile=profile, app_key=target.app_key, publish=publish, response=response)
 
         payload = _build_form_payload_from_fields(
             title=schema_result.get("formTitle") or target.app_name,
@@ -858,6 +1127,11 @@ class AiBuilderFacade:
             fields=current_fields,
             layout=layout,
         )
+        payload["editVersionNo"] = self._resolve_form_edit_version(
+            profile=profile,
+            app_key=target.app_key,
+            current_schema=schema_result,
+        )
         try:
             self.apps.app_update_form_schema(profile=profile, app_key=target.app_key, payload=payload)
         except (QingflowApiError, RuntimeError) as error:
@@ -873,13 +1147,8 @@ class AiBuilderFacade:
                 },
                 suggested_next_call={"tool_name": "app_read_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
             )
-        verified = self.app_read(profile=profile, app_key=target.app_key, include_raw=False)
-        verified_field_names = {field["name"] for field in verified["schema"]["fields"]}
-        tag_ids_after = _coerce_int_list((self.apps.app_get_base(profile=profile, app_key=target.app_key, include_raw=True).get("result") or {}).get("tagIds"))
-        verification_ok = all(name in verified_field_names for name in added + updated) and all(name not in verified_field_names for name in removed)
-        package_attached = None if package_tag_id is None else package_tag_id in tag_ids_after
-        return {
-            "status": "success" if verification_ok and (package_attached is not False) else "partial_success",
+        response = {
+            "status": "success",
             "error_code": None,
             "recoverable": False,
             "message": "applied schema patch",
@@ -888,21 +1157,11 @@ class AiBuilderFacade:
             "allowed_values": {"field_types": [item.value for item in PublicFieldType]},
             "details": {},
             "request_id": None,
-            "suggested_next_call": None
-            if package_attached is not False
-            else {
-                "tool_name": "package_attach_app",
-                "arguments": {
-                    "profile": profile,
-                    "tag_id": package_tag_id,
-                    "app_key": target.app_key,
-                    "app_title": app_title or target.app_name,
-                },
-            },
+            "suggested_next_call": None,
             "noop": False,
             "verification": {
-                "fields_verified": verification_ok,
-                "package_attached": package_attached,
+                "fields_verified": False,
+                "package_attached": None,
             },
             "app_key": target.app_key,
             "created": bool(resolved.get("created")),
@@ -911,10 +1170,71 @@ class AiBuilderFacade:
                 "updated": updated,
                 "removed": removed,
             },
-            "verified": verification_ok,
-            "tag_ids_after": tag_ids_after,
-            "package_attached": package_attached,
+            "verified": False,
+            "tag_ids_after": [],
+            "package_attached": None,
         }
+        if schema_readback_delayed:
+            response["verification"]["schema_readback_delayed"] = True
+        response = self._append_publish_result(profile=profile, app_key=target.app_key, publish=publish, response=response)
+        verification_ok = False
+        tag_ids_after: list[int] = []
+        package_attached: bool | None = None
+        verification_error: QingflowApiError | None = None
+        try:
+            verified = self.app_read(profile=profile, app_key=target.app_key, include_raw=False)
+            verified_field_names = {field["name"] for field in verified["schema"]["fields"]}
+            verification_ok = all(name in verified_field_names for name in added + updated) and all(name not in verified_field_names for name in removed)
+        except (QingflowApiError, RuntimeError) as error:
+            verification_error = _coerce_api_error(error)
+            verification_ok = False
+        try:
+            base_info = self.apps.app_get_base(profile=profile, app_key=target.app_key, include_raw=True).get("result") or {}
+            tag_ids_after = _coerce_int_list(base_info.get("tagIds"))
+            package_attached = None if package_tag_id is None else package_tag_id in tag_ids_after
+        except (QingflowApiError, RuntimeError) as error:
+            base_error = _coerce_api_error(error)
+            if verification_error is None:
+                verification_error = base_error
+            tag_ids_after = []
+            package_attached = None if package_tag_id is None else False
+        response["verification"]["fields_verified"] = verification_ok
+        response["verification"]["package_attached"] = package_attached
+        response["verified"] = verification_ok
+        response["tag_ids_after"] = tag_ids_after
+        response["package_attached"] = package_attached
+        if package_attached is False:
+            response["suggested_next_call"] = {
+                "tool_name": "package_attach_app",
+                "arguments": {
+                    "profile": profile,
+                    "tag_id": package_tag_id,
+                    "app_key": target.app_key,
+                    "app_title": app_name or target.app_name,
+                },
+            }
+        publish_failed = bool(response.get("publish_requested")) and not bool(response.get("published"))
+        if verification_ok and package_attached is not False and not publish_failed:
+            response["status"] = "success"
+        else:
+            response["status"] = "partial_success"
+        if verification_error is not None:
+            response["recoverable"] = True
+            response["error_code"] = response.get("error_code") or (
+                "READBACK_PENDING" if verification_error.http_status == 404 else "READBACK_FAILED"
+            )
+            response["message"] = f"{response.get('message') or 'apply succeeded'}; readback pending"
+            response["request_id"] = response.get("request_id") or verification_error.request_id
+            details = response.get("details")
+            if not isinstance(details, dict):
+                details = {}
+                response["details"] = details
+            details["verification_error"] = {
+                "message": verification_error.message,
+                "http_status": verification_error.http_status,
+                "backend_code": verification_error.backend_code,
+            }
+        return response
 
     def app_layout_apply(
         self,
@@ -923,22 +1243,25 @@ class AiBuilderFacade:
         app_key: str,
         mode: LayoutApplyMode = LayoutApplyMode.merge,
         sections: list[LayoutSectionPatch],
+        publish: bool = True,
     ) -> JSONObject:
         normalized_args = {
             "app_key": app_key,
             "mode": mode.value,
             "sections": [section.model_dump(mode="json") for section in sections],
+            "publish": publish,
         }
-        schema = self.apps.app_get_form_schema(
-            profile=profile,
-            app_key=app_key,
-            form_type=1,
-            being_draft=True,
-            being_apply=None,
-            audit_node_id=None,
-            include_raw=True,
-        )
-        schema_result = schema.get("result") if isinstance(schema.get("result"), dict) else {}
+        try:
+            schema_result, _schema_source = self._read_schema_with_fallback(profile=profile, app_key=app_key)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "LAYOUT_READ_FAILED",
+                api_error,
+                normalized_args=normalized_args,
+                details={"app_key": app_key},
+                suggested_next_call={"tool_name": "app_read_layout_summary", "arguments": {"profile": profile, "app_key": app_key}},
+            )
         parsed = _parse_schema(schema_result)
         current_fields = parsed["fields"]
         fields_by_name = {field["name"]: field for field in current_fields}
@@ -996,7 +1319,7 @@ class AiBuilderFacade:
             else merged["layout"]
         )
         if _layouts_equal(parsed["layout"], target_layout):
-            return {
+            response = {
                 "status": "success",
                 "error_code": None,
                 "recoverable": False,
@@ -1019,10 +1342,16 @@ class AiBuilderFacade:
                 },
                 "verified": True,
             }
+            return self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response)
         payload = _build_form_payload_from_existing_schema(
             current_schema=schema_result,
             layout=target_layout,
         )
+        payload["editVersionNo"] = self._resolve_form_edit_version(
+            profile=profile,
+            app_key=app_key,
+            current_schema=schema_result,
+        )
         applied_layout = target_layout
         fallback_applied = None
         try:
@@ -1035,6 +1364,11 @@ class AiBuilderFacade:
                     current_schema=schema_result,
                     layout=flattened_layout,
                 )
+                fallback_payload["editVersionNo"] = self._resolve_form_edit_version(
+                    profile=profile,
+                    app_key=app_key,
+                    current_schema=schema_result,
+                )
                 try:
                     self.apps.app_update_form_schema(profile=profile, app_key=app_key, payload=fallback_payload)
                     applied_layout = flattened_layout
@@ -1068,8 +1402,33 @@ class AiBuilderFacade:
                     },
                     suggested_next_call={"tool_name": "app_layout_plan", "arguments": {"profile": profile, **normalized_args}},
                 )
-        verified = self.app_read(profile=profile, app_key=app_key, include_raw=False)
-        return {
+        verified = self.app_read_layout_summary(profile=profile, app_key=app_key)
+        if verified.get("status") == "failed":
+            response = {
+                "status": "partial_success",
+                "error_code": "LAYOUT_READBACK_PENDING",
+                "recoverable": True,
+                "message": "applied app layout; layout readback pending",
+                "normalized_args": normalized_args,
+                "missing_fields": [],
+                "allowed_values": {"modes": ["merge", "replace"]},
+                "details": {},
+                "request_id": verified.get("request_id"),
+                "suggested_next_call": {"tool_name": "app_read_layout_summary", "arguments": {"profile": profile, "app_key": app_key}},
+                "noop": False,
+                "verification": {"layout_verified": False, "layout_read_unavailable": True},
+                "app_key": app_key,
+                "layout_diff": {
+                    "mode": mode.value,
+                    "replaced": mode == LayoutApplyMode.replace,
+                    "merged": mode == LayoutApplyMode.merge,
+                    "auto_added_fields": merged["auto_added_fields"] if mode == LayoutApplyMode.merge else [],
+                    "fallback_applied": fallback_applied,
+                },
+                "verified": False,
+            }
+            return self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response)
+        response = {
             "status": "partial_success" if fallback_applied else "success",
             "error_code": None,
             "recoverable": False,
@@ -1081,7 +1440,7 @@ class AiBuilderFacade:
             "request_id": None,
             "suggested_next_call": None,
             "noop": False,
-            "verification": {"layout_verified": verified["layout"] == applied_layout},
+            "verification": {"layout_verified": verified["sections"] == applied_layout.get("sections", [])},
             "app_key": app_key,
             "layout_diff": {
                 "mode": mode.value,
@@ -1090,8 +1449,9 @@ class AiBuilderFacade:
                 "auto_added_fields": merged["auto_added_fields"] if mode == LayoutApplyMode.merge else [],
                 "fallback_applied": fallback_applied,
             },
-            "verified": verified["layout"] == applied_layout,
+            "verified": verified["sections"] == applied_layout.get("sections", []),
         }
+        return self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response)
 
     def app_flow_apply(
         self,
@@ -1101,12 +1461,14 @@ class AiBuilderFacade:
         nodes: list[dict[str, Any]],
         transitions: list[dict[str, Any]],
         mode: str = "replace",
+        publish: bool = True,
     ) -> JSONObject:
         normalized_args = {
             "app_key": app_key,
             "mode": mode,
             "nodes": nodes,
             "transitions": transitions,
+            "publish": publish,
         }
         if mode != "replace":
             return _failed(
@@ -1116,16 +1478,18 @@ class AiBuilderFacade:
                 allowed_values={"modes": ["replace"]},
                 suggested_next_call={"tool_name": "app_flow_plan", "arguments": {"profile": profile, **normalized_args}},
             )
-        base = self.apps.app_get_base(profile=profile, app_key=app_key, include_raw=True).get("result") or {}
-        schema = self.apps.app_get_form_schema(
-            profile=profile,
-            app_key=app_key,
-            form_type=1,
-            being_draft=True,
-            being_apply=None,
-            audit_node_id=None,
-            include_raw=True,
-        ).get("result") or {}
+        try:
+            base = self.apps.app_get_base(profile=profile, app_key=app_key, include_raw=True).get("result") or {}
+            schema, _schema_source = self._read_schema_with_fallback(profile=profile, app_key=app_key)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "FLOW_READ_FAILED",
+                api_error,
+                normalized_args=normalized_args,
+                details={"app_key": app_key},
+                suggested_next_call={"tool_name": "app_read_flow_summary", "arguments": {"profile": profile, "app_key": app_key}},
+            )
         entity = _entity_spec_from_app(base_info=base, schema=schema, views=None)
         workflow_spec = _build_public_workflow_spec(nodes=nodes, transitions=transitions)
         if workflow_spec.get("status") == "failed":
@@ -1134,7 +1498,8 @@ class AiBuilderFacade:
             workflow_spec["suggested_next_call"] = {"tool_name": "app_flow_plan", "arguments": {"profile": profile, **normalized_args}}
             return workflow_spec
         desired_node_count = len([node for node in nodes if node.get("type") != "end"])
-        current_node_count = len(_summarize_workflow_nodes(self.workflows.workflow_list_nodes(profile=profile, app_key=app_key).get("result")))
+        current_workflow, _workflow_unavailable = self._load_workflow_result(profile=profile, app_key=app_key, tolerate_404=True)
+        current_node_count = len(_summarize_workflow_nodes(current_workflow))
         if current_node_count == desired_node_count and desired_node_count > 0:
             # Lightweight idempotency check for repeat submissions of same simple graph.
             pass
@@ -1146,42 +1511,57 @@ class AiBuilderFacade:
             os.environ["QINGFLOW_MCP_BUILD_HOME"] = temporary_build_home
         try:
             assembly = BuildAssemblyStore.open(build_id=build_id, create=True)
+            manifest = default_manifest()
+            manifest["solution_name"] = base.get("formTitle") or app_key
+            manifest["preferences"]["create_package"] = False
+            manifest["preferences"]["create_portal"] = False
+            manifest["preferences"]["create_navigation"] = False
+            manifest["entities"] = [entity]
+            assembly.set_manifest(manifest)
+            artifacts = default_artifacts()
+            artifacts["apps"][entity["entity_id"]] = {"app_key": app_key}
+            assembly.set_artifacts(artifacts)
+            flow_stage_spec = {
+                "solution_name": manifest["solution_name"],
+                "entities": [{"entity_id": entity["entity_id"], "workflow": workflow_spec["workflow"]}],
+            }
+            assembly.set_stage_spec("app_flow", flow_stage_spec)
+            stage = self.solutions.solution_build_flow(
+                profile=profile,
+                mode="apply",
+                build_id=build_id,
+                flow_spec=flow_stage_spec,
+                publish=False,
+                run_label=None,
+                repair_patch={},
+            )
         finally:
             if previous_build_home is None:
                 os.environ.pop("QINGFLOW_MCP_BUILD_HOME", None)
-        manifest = default_manifest()
-        manifest["solution_name"] = base.get("formTitle") or app_key
-        manifest["preferences"]["create_package"] = False
-        manifest["preferences"]["create_portal"] = False
-        manifest["preferences"]["create_navigation"] = False
-        manifest["entities"] = [entity]
-        assembly.set_manifest(manifest)
-        artifacts = default_artifacts()
-        artifacts["apps"][entity["entity_id"]] = {"app_key": app_key}
-        assembly.set_artifacts(artifacts)
-        stage = self.solutions.solution_build_flow(
-            profile=profile,
-            mode="apply",
-            build_id=build_id,
-            flow_spec={
-                "solution_name": manifest["solution_name"],
-                "entities": [{"entity_id": entity["entity_id"], "workflow": workflow_spec["workflow"]}],
-            },
-            publish=False,
-            run_label=None,
-            repair_patch={},
-        )
         if stage.get("status") != "success":
             failed = _normalize_flow_stage_failure(stage, profile=profile, app_key=app_key, entity=entity)
             failed["normalized_args"] = normalized_args
-            failed["suggested_next_call"] = failed.get("suggested_next_call") or {"tool_name": "app_flow_plan", "arguments": {"profile": profile, **normalized_args}}
+            suggested_next_call = failed.get("suggested_next_call")
+            if not isinstance(suggested_next_call, dict):
+                suggested_next_call = {"tool_name": "app_flow_plan", "arguments": {"profile": profile, **normalized_args}}
+            elif suggested_next_call.get("tool_name") == "app_flow_plan":
+                arguments = suggested_next_call.get("arguments")
+                if not isinstance(arguments, dict):
+                    arguments = {}
+                arguments.setdefault("profile", profile)
+                arguments.setdefault("app_key", app_key)
+                arguments.setdefault("mode", mode)
+                arguments.setdefault("nodes", nodes)
+                arguments.setdefault("transitions", transitions)
+                suggested_next_call["arguments"] = arguments
+            failed["suggested_next_call"] = suggested_next_call
             return failed
-        verified_nodes = self.workflows.workflow_list_nodes(profile=profile, app_key=app_key).get("result")
-        return {
-            "status": "success",
+        verified_nodes, verified_nodes_unavailable = self._load_workflow_result(profile=profile, app_key=app_key, tolerate_404=True)
+        response = {
+            "status": "success" if bool(verified_nodes) or not verified_nodes_unavailable else "partial_success",
             "error_code": None,
-            "recoverable": False,
-            "message": "applied workflow patch",
+            "recoverable": bool(verified_nodes_unavailable),
+            "message": "applied workflow patch" if not verified_nodes_unavailable else "applied workflow patch; flow readback pending",
             "normalized_args": normalized_args,
             "missing_fields": [],
             "allowed_values": {"modes": ["replace"]},
@@ -1189,11 +1569,15 @@ class AiBuilderFacade:
             "request_id": None,
             "suggested_next_call": None,
             "noop": False,
-            "verification": {"workflow_verified": bool(verified_nodes)},
+            "verification": {"workflow_verified": bool(verified_nodes), "workflow_read_unavailable": verified_nodes_unavailable},
             "app_key": app_key,
             "flow_diff": {"mode": "replace", "node_count": desired_node_count},
             "verified": bool(verified_nodes),
         }
+        if verified_nodes_unavailable:
+            response["error_code"] = "FLOW_READBACK_PENDING"
+            response["suggested_next_call"] = {"tool_name": "app_read_flow_summary", "arguments": {"profile": profile, "app_key": app_key}}
+        return self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response)
 
     def app_views_apply(
         self,
@@ -1202,14 +1586,16 @@ class AiBuilderFacade:
         app_key: str,
         upsert_views: list[ViewUpsertPatch],
         remove_views: list[str],
+        publish: bool = True,
     ) -> JSONObject:
         normalized_args = {
             "app_key": app_key,
             "upsert_views": [patch.model_dump(mode="json") for patch in upsert_views],
             "remove_views": list(remove_views),
+            "publish": publish,
         }
         if not upsert_views and not remove_views:
-            return {
+            response = {
                 "status": "success",
                 "error_code": None,
                 "recoverable": False,
@@ -1226,17 +1612,21 @@ class AiBuilderFacade:
                 "views_diff": {"created": [], "updated": [], "removed": []},
                 "verified": True,
             }
-        base = self.apps.app_get_base(profile=profile, app_key=app_key, include_raw=True).get("result") or {}
-        schema = self.apps.app_get_form_schema(
-            profile=profile,
-            app_key=app_key,
-            form_type=1,
-            being_draft=True,
-            being_apply=None,
-            audit_node_id=None,
-            include_raw=True,
-        ).get("result") or {}
-        existing_views = self.views.view_list_flat(profile=profile, app_key=app_key).get("result") or []
+            return self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response)
+        try:
+            base = self.apps.app_get_base(profile=profile, app_key=app_key, include_raw=True).get("result") or {}
+            schema, _schema_source = self._read_schema_with_fallback(profile=profile, app_key=app_key)
+            existing_views, _views_unavailable = self._load_views_result(profile=profile, app_key=app_key, tolerate_404=False)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "VIEWS_READ_FAILED",
+                api_error,
+                normalized_args=normalized_args,
+                details={"app_key": app_key},
+                suggested_next_call={"tool_name": "app_read_views_summary", "arguments": {"profile": profile, "app_key": app_key}},
+            )
+        existing_views = existing_views or []
         existing_by_name = {}
         for view in existing_views if isinstance(existing_views, list) else []:
             if not isinstance(view, dict):
@@ -1328,6 +1718,33 @@ class AiBuilderFacade:
                     created.append(patch.name)
             except (QingflowApiError, RuntimeError) as error:
                 api_error = _coerce_api_error(error)
+                if api_error.backend_code == 48104:
+                    try:
+                        if existing_key or created_key:
+                            target_key = created_key or existing_key or ""
+                            fallback_payload = _build_minimal_view_payload(
+                                app_key=app_key,
+                                schema=schema,
+                                patch=patch,
+                                ordinal=ordinal,
+                            )
+                            self.views.view_update(profile=profile, viewgraph_key=target_key, payload=fallback_payload)
+                            if existing_key:
+                                updated.append(patch.name)
+                            else:
+                                created.append(patch.name)
+                            continue
+                        fallback_payload = _build_minimal_view_payload(
+                            app_key=app_key,
+                            schema=schema,
+                            patch=patch,
+                            ordinal=ordinal,
+                        )
+                        self.views.view_create(profile=profile, payload=fallback_payload)
+                        created.append(patch.name)
+                        continue
+                    except (QingflowApiError, RuntimeError) as fallback_error:
+                        api_error = _coerce_api_error(fallback_error)
                 if created_key:
                     try:
                         self.views.view_delete(profile=profile, viewgraph_key=created_key)
@@ -1343,32 +1760,49 @@ class AiBuilderFacade:
                         "view_type": patch.type.value,
                         "columns": patch.columns,
                         "group_by": patch.group_by,
+                        "operation": "update" if existing_key or created_key else "create",
                     },
                     suggested_next_call={
                         "tool_name": "app_views_plan",
                         "arguments": {"profile": profile, "app_key": app_key},
                     },
                 )
-        verified_names = {item.get("viewgraphName") or item.get("viewName") or item.get("title") for item in (self.views.view_list_flat(profile=profile, app_key=app_key).get("result") or []) if isinstance(item, dict)}
-        verified = all(name in verified_names for name in created + updated) and all(name not in verified_names for name in removed)
+        try:
+            verified_view_result, verified_views_unavailable = self._load_views_result(profile=profile, app_key=app_key, tolerate_404=True)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "VIEWS_READ_FAILED",
+                api_error,
+                normalized_args=normalized_args,
+                details={"app_key": app_key},
+                suggested_next_call={"tool_name": "app_read_views_summary", "arguments": {"profile": profile, "app_key": app_key}},
+            )
+        verified_names = {
+            item.get("viewgraphName") or item.get("viewName") or item.get("title")
+            for item in (verified_view_result or [])
+            if isinstance(item, dict)
+        }
+        verified = (not verified_views_unavailable) and all(name in verified_names for name in created + updated) and all(name not in verified_names for name in removed)
         noop = not created and not updated and not removed
-        return {
+        response = {
             "status": "success" if verified else "partial_success",
-            "error_code": None,
-            "recoverable": False,
-            "message": "applied view patch",
+            "error_code": None if not verified_views_unavailable else "VIEWS_READBACK_PENDING",
+            "recoverable": bool(verified_views_unavailable),
+            "message": "applied view patch" if not verified_views_unavailable else "applied view patch; views readback pending",
             "normalized_args": normalized_args,
             "missing_fields": [],
             "allowed_values": {"view_types": ["table", "card", "board"]},
             "details": {},
             "request_id": None,
-            "suggested_next_call": None,
+            "suggested_next_call": None if not verified_views_unavailable else {"tool_name": "app_read_views_summary", "arguments": {"profile": profile, "app_key": app_key}},
             "noop": noop,
-            "verification": {"views_verified": verified},
+            "verification": {"views_verified": verified, "views_read_unavailable": verified_views_unavailable},
             "app_key": app_key,
             "views_diff": {"created": created, "updated": updated, "removed": removed},
             "verified": verified,
         }
+        return self._append_publish_result(profile=profile, app_key=app_key, publish=publish, response=response)
 
     def app_publish_verify(
         self,
@@ -1378,12 +1812,33 @@ class AiBuilderFacade:
         expected_package_tag_id: int | None = None,
     ) -> JSONObject:
         normalized_args = {"app_key": app_key, "expected_package_tag_id": expected_package_tag_id}
-        base_before = self.apps.app_get_base(profile=profile, app_key=app_key, include_raw=True).get("result") or {}
+        try:
+            base_before = self.apps.app_get_base(profile=profile, app_key=app_key, include_raw=True).get("result") or {}
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "APP_READ_FAILED",
+                api_error,
+                normalized_args=normalized_args,
+                details={"app_key": app_key},
+                suggested_next_call={"tool_name": "app_read_summary", "arguments": {"profile": profile, "app_key": app_key}},
+            )
         tag_ids_before = _coerce_int_list(base_before.get("tagIds"))
         already_published = bool(base_before.get("appPublishStatus") in {1, 2})
         package_already_attached = None if not expected_package_tag_id else expected_package_tag_id in tag_ids_before
-        views_before = self.views.view_list_flat(profile=profile, app_key=app_key).get("result") or []
-        if already_published and package_already_attached is not False and isinstance(views_before, list):
+        try:
+            views_before, views_before_unavailable = self._load_views_result(profile=profile, app_key=app_key, tolerate_404=True)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "VIEWS_READ_FAILED",
+                api_error,
+                normalized_args=normalized_args,
+                details={"app_key": app_key},
+                suggested_next_call={"tool_name": "app_read_views_summary", "arguments": {"profile": profile, "app_key": app_key}},
+            )
+        views_before = views_before or []
+        if already_published and package_already_attached is not False and isinstance(views_before, list) and not views_before_unavailable:
             return {
                 "status": "success",
                 "error_code": None,
@@ -1418,17 +1873,38 @@ class AiBuilderFacade:
                 details={"app_key": app_key, "edit_version_no": edit_version_no},
                 suggested_next_call={"tool_name": "app_read_summary", "arguments": {"profile": profile, "app_key": app_key}},
             )
-        base = self.apps.app_get_base(profile=profile, app_key=app_key, include_raw=True).get("result") or {}
+        try:
+            base = self.apps.app_get_base(profile=profile, app_key=app_key, include_raw=True).get("result") or {}
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "APP_READ_FAILED",
+                api_error,
+                normalized_args=normalized_args,
+                details={"app_key": app_key},
+                suggested_next_call={"tool_name": "app_read_summary", "arguments": {"profile": profile, "app_key": app_key}},
+            )
         tag_ids_after = _coerce_int_list(base.get("tagIds"))
         package_attached = None if not expected_package_tag_id else expected_package_tag_id in tag_ids_after
-        views = self.views.view_list_flat(profile=profile, app_key=app_key).get("result") or []
-        views_ok = isinstance(views, list)
+        try:
+            views, views_unavailable = self._load_views_result(profile=profile, app_key=app_key, tolerate_404=True)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "VIEWS_READ_FAILED",
+                api_error,
+                normalized_args=normalized_args,
+                details={"app_key": app_key},
+                suggested_next_call={"tool_name": "app_read_views_summary", "arguments": {"profile": profile, "app_key": app_key}},
+            )
+        views = views or []
+        views_ok = isinstance(views, list) and not views_unavailable
         verified = bool(base.get("appPublishStatus") in {1, 2}) and (package_attached is not False) and views_ok
         return {
             "status": "success" if verified else "partial_success",
-            "error_code": None,
-            "recoverable": False,
-            "message": "published and verified app",
+            "error_code": None if not views_unavailable else "VIEWS_READBACK_PENDING",
+            "recoverable": bool(views_unavailable),
+            "message": "published and verified app" if not views_unavailable else "published app; views readback pending",
             "normalized_args": normalized_args,
             "missing_fields": [],
             "allowed_values": {},
@@ -1441,7 +1917,7 @@ class AiBuilderFacade:
                 "arguments": {"profile": profile, "tag_id": expected_package_tag_id, "app_key": app_key},
             },
             "noop": False,
-            "verification": {"published": bool(base.get("appPublishStatus") in {1, 2}), "package_attached": package_attached, "views_ok": views_ok},
+            "verification": {"published": bool(base.get("appPublishStatus") in {1, 2}), "package_attached": package_attached, "views_ok": views_ok, "views_read_unavailable": views_unavailable},
             "app_key": app_key,
             "published": bool(base.get("appPublishStatus") in {1, 2}),
             "package_attached": package_attached,
@@ -1450,29 +1926,151 @@ class AiBuilderFacade:
             "verified": verified,
         }
 
-    def _load_app_state(self, *, profile: str, app_key: str) -> dict[str, Any]:
+    def _publish_current_edit_version(self, *, profile: str, app_key: str) -> JSONObject:
+        normalized_args = {"app_key": app_key}
+        version_result = self.apps.app_get_edit_version_no(profile=profile, app_key=app_key).get("result") or {}
+        edit_version_no = _coerce_positive_int(version_result.get("editVersionNo") or version_result.get("versionNo")) or 1
+        try:
+            self.apps.app_publish(profile=profile, app_key=app_key, payload={"editVersionNo": edit_version_no})
+            self.apps.app_edit_finished(profile=profile, app_key=app_key, payload={"editVersionNo": edit_version_no})
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            return _failed_from_api_error(
+                "PUBLISH_FAILED",
+                api_error,
+                normalized_args=normalized_args,
+                details={"app_key": app_key, "edit_version_no": edit_version_no},
+                suggested_next_call={"tool_name": "app_publish_verify", "arguments": {"profile": profile, "app_key": app_key}},
+            )
+        return {
+            "status": "success",
+            "error_code": None,
+            "recoverable": False,
+            "message": "published current app draft",
+            "normalized_args": normalized_args,
+            "missing_fields": [],
+            "allowed_values": {},
+            "details": {"app_key": app_key, "edit_version_no": edit_version_no},
+            "request_id": None,
+            "suggested_next_call": None,
+            "noop": False,
+            "verification": {"published": True},
+            "app_key": app_key,
+            "published": True,
+        }
+
+    def _resolve_form_edit_version(self, *, profile: str, app_key: str, current_schema: dict[str, Any]) -> int:
+        try:
+            version_result = self.apps.app_get_edit_version_no(profile=profile, app_key=app_key).get("result") or {}
+        except (QingflowApiError, RuntimeError):
+            version_result = {}
+        return _coerce_positive_int(version_result.get("editVersionNo") or version_result.get("versionNo")) or int(current_schema.get("editVersionNo") or 1)
+
+    def _append_publish_result(self, *, profile: str, app_key: str, publish: bool, response: JSONObject) -> JSONObject:
+        response["publish_requested"] = publish
+        if not publish:
+            response["published"] = False
+            return response
+        publish_result = self._publish_current_edit_version(profile=profile, app_key=app_key)
+        response["publish_result"] = publish_result
+        response["published"] = bool(publish_result.get("published"))
+        verification = response.get("verification")
+        if not isinstance(verification, dict):
+            verification = {}
+            response["verification"] = verification
+        verification["published"] = bool(publish_result.get("published"))
+        if publish_result.get("status") == "failed":
+            response["status"] = "partial_success"
+            response["error_code"] = response.get("error_code") or publish_result.get("error_code")
+            response["recoverable"] = True
+            response["message"] = f"{response.get('message') or 'apply succeeded'}; publish failed"
+            if not response.get("suggested_next_call"):
+                response["suggested_next_call"] = publish_result.get("suggested_next_call")
+        return response
+
+    def _load_base_schema_state(self, *, profile: str, app_key: str) -> dict[str, Any]:
         base = self.apps.app_get_base(profile=profile, app_key=app_key, include_raw=True)
-        schema = self.apps.app_get_form_schema(
-            profile=profile,
-            app_key=app_key,
-            form_type=1,
-            being_draft=True,
-            being_apply=None,
-            audit_node_id=None,
-            include_raw=True,
-        )
-        views = self.views.view_list_flat(profile=profile, app_key=app_key)
-        workflow = self.workflows.workflow_list_nodes(profile=profile, app_key=app_key)
+        schema_result, schema_source = self._read_schema_with_fallback(profile=profile, app_key=app_key)
         base_result = base.get("result") if isinstance(base.get("result"), dict) else {}
-        schema_result = schema.get("result") if isinstance(schema.get("result"), dict) else {}
         return {
             "base": base_result,
             "schema": schema_result,
             "parsed": _parse_schema(schema_result),
-            "views": views.get("result"),
-            "workflow": workflow.get("result"),
+            "schema_source": schema_source,
         }
 
+    def _load_views_result(self, *, profile: str, app_key: str, tolerate_404: bool) -> tuple[Any, bool]:
+        try:
+            views = self.views.view_list_flat(profile=profile, app_key=app_key)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            if api_error.http_status == 404:
+                try:
+                    legacy_views = self.views.view_list(profile=profile, app_key=app_key)
+                except (QingflowApiError, RuntimeError) as legacy_error:
+                    legacy_api_error = _coerce_api_error(legacy_error)
+                    if tolerate_404 and legacy_api_error.http_status == 404:
+                        return [], True
+                    raise
+                legacy_result = legacy_views.get("result")
+                if _is_view_collection_shape(legacy_result):
+                    return _normalize_view_collection(legacy_result), False
+                if tolerate_404:
+                    return [], True
+                raise error
+            raise
+        return _normalize_view_collection(views.get("result")), False
+
+    def _load_workflow_result(self, *, profile: str, app_key: str, tolerate_404: bool) -> tuple[Any, bool]:
+        try:
+            workflow = self.workflows.workflow_list_nodes(profile=profile, app_key=app_key)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            if tolerate_404 and api_error.http_status == 404:
+                return [], True
+            raise
+        return workflow.get("result"), False
+
+    def _load_app_state(self, *, profile: str, app_key: str) -> dict[str, Any]:
+        state = self._load_base_schema_state(profile=profile, app_key=app_key)
+        views, views_unavailable = self._load_views_result(profile=profile, app_key=app_key, tolerate_404=True)
+        workflow, workflow_unavailable = self._load_workflow_result(profile=profile, app_key=app_key, tolerate_404=True)
+        state["views"] = views
+        state["workflow"] = workflow
+        state["views_unavailable"] = views_unavailable
+        state["workflow_unavailable"] = workflow_unavailable
+        return state
+
+    def _read_schema_with_fallback(self, *, profile: str, app_key: str) -> tuple[dict[str, Any], str]:
+        attempts = (
+            ("draft", True),
+            ("current", None),
+            ("published", False),
+        )
+        last_error: Exception | None = None
+        for label, being_draft in attempts:
+            try:
+                schema = self.apps.app_get_form_schema(
+                    profile=profile,
+                    app_key=app_key,
+                    form_type=1,
+                    being_draft=being_draft,
+                    being_apply=None,
+                    audit_node_id=None,
+                    include_raw=True,
+                )
+                result = schema.get("result")
+                return (result if isinstance(result, dict) else {}), label
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = _coerce_api_error(error)
+                last_error = error
+                if api_error.http_status == 404:
+                    continue
+                raise
+        if last_error is not None:
+            raise last_error
+        return {}, "unknown"
+
     def _preview_target_app(
         self,
         *,
@@ -1516,33 +2114,72 @@ class AiBuilderFacade:
         *,
         profile: str,
         app_key: str,
-        app_title: str,
+        app_name: str,
         package_tag_id: int | None,
         create_if_missing: bool,
     ) -> JSONObject:
         if app_key:
             return self.app_resolve(profile=profile, app_key=app_key)
-        if app_title:
-            resolved = self.app_resolve(profile=profile, app_name=app_title, package_tag_id=package_tag_id)
+        if app_name:
+            resolved = self.app_resolve(profile=profile, app_name=app_name, package_tag_id=package_tag_id)
             if resolved.get("status") == "success":
                 return resolved
             if not create_if_missing:
                 return resolved
         elif not create_if_missing:
-            return _failed("APP_NAME_REQUIRED", "app_title or app_key is required", suggested_next_call=None)
+            return _failed("APP_NAME_REQUIRED", "app_name or app_key is required", suggested_next_call=None)
         if not create_if_missing:
             return _failed("APP_NOT_FOUND", "target app was not found", suggested_next_call=None)
         payload: JSONObject = {
-            "appName": app_title or "未命名应用",
+            "appName": app_name or "未命名应用",
             "auth": default_member_auth(),
             "tagIds": [],
         }
-        created = self.apps.app_create(profile=profile, payload=payload)
+        try:
+            created = self.apps.app_create(profile=profile, payload=payload)
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            request_route = self._current_request_route(profile)
+            return _failed_from_api_error(
+                "CREATE_APP_ROUTE_NOT_FOUND" if api_error.http_status == 404 else "APP_CREATE_FAILED",
+                api_error,
+                details={
+                    "app_name": app_name,
+                    "package_tag_id": package_tag_id,
+                    "request_route": request_route,
+                },
+                suggested_next_call=(
+                    {"tool_name": "workspace_select", "arguments": {"profile": profile, "ws_id": request_route.get("ws_id")}}
+                    if request_route.get("ws_id")
+                    else None
+                ),
+            )
         result = created.get("result") if isinstance(created.get("result"), dict) else {}
         new_app_key = str(result.get("appKey") or (result.get("appKeys")[0] if isinstance(result.get("appKeys"), list) and result.get("appKeys") else ""))
         if not new_app_key:
             return _failed("APP_CREATE_FAILED", "failed to create app shell", details={"result": result}, suggested_next_call=None)
-        base = self.apps.app_get_base(profile=profile, app_key=new_app_key, include_raw=True).get("result") or {}
+        try:
+            base = self.apps.app_get_base(profile=profile, app_key=new_app_key, include_raw=True).get("result") or {}
+        except (QingflowApiError, RuntimeError) as error:
+            api_error = _coerce_api_error(error)
+            if api_error.http_status != 404:
+                return _failed_from_api_error(
+                    "APP_CREATE_READBACK_FAILED",
+                    api_error,
+                    details={"app_key": new_app_key, "app_name": app_name, "package_tag_id": package_tag_id},
+                    suggested_next_call={"tool_name": "app_read_summary", "arguments": {"profile": profile, "app_key": new_app_key}},
+                )
+            return {
+                "status": "success",
+                "error_code": None,
+                "recoverable": False,
+                "message": "created app; base readback pending",
+                "suggested_next_call": None,
+                "app_key": new_app_key,
+                "app_name": app_name or "未命名应用",
+                "tag_ids": [],
+                "created": True,
+            }
         return {
             "status": "success",
             "error_code": None,
@@ -1550,11 +2187,56 @@ class AiBuilderFacade:
             "message": "created app",
             "suggested_next_call": None,
             "app_key": new_app_key,
-            "app_name": base.get("formTitle") or app_title or "未命名应用",
+            "app_name": base.get("formTitle") or app_name or "未命名应用",
             "tag_ids": _coerce_int_list(base.get("tagIds")),
             "created": True,
         }
 
+    def _current_request_route(self, profile: str) -> JSONObject:
+        session_profile = self.apps.sessions.get_profile(profile)
+        backend_session = self.apps.sessions.get_backend_session(profile)
+        if session_profile is None or backend_session is None:
+            return {}
+        context = BackendRequestContext(
+            base_url=backend_session.base_url,
+            token=backend_session.token,
+            ws_id=session_profile.selected_ws_id,
+            qf_version=backend_session.qf_version,
+            qf_version_source=backend_session.qf_version_source,
+        )
+        describe_route = getattr(self.apps.backend, "describe_route", None)
+        route = describe_route(context) if callable(describe_route) else None
+        payload = dict(route) if isinstance(route, dict) else {}
+        payload.setdefault("ws_id", session_profile.selected_ws_id)
+        return payload
+
+    def _resolve_current_user_identity(self, *, profile: str) -> JSONObject:
+        session_profile = self.apps.sessions.get_profile(profile)
+        backend_session = self.apps.sessions.get_backend_session(profile)
+        current_email = str((session_profile.email if session_profile else None) or "").strip()
+        current_name = str((session_profile.nick_name if session_profile else None) or "").strip()
+        if current_email or current_name or session_profile is None or backend_session is None:
+            return {"email": current_email or None, "nick_name": current_name or None}
+        try:
+            user_info = self.apps.backend.request(
+                "GET",
+                BackendRequestContext(
+                    base_url=backend_session.base_url,
+                    token=backend_session.token,
+                    ws_id=session_profile.selected_ws_id,
+                    qf_version=backend_session.qf_version,
+                    qf_version_source=backend_session.qf_version_source,
+                ),
+                "/user",
+            )
+        except (QingflowApiError, RuntimeError):
+            return {"email": current_email or None, "nick_name": current_name or None}
+        if not isinstance(user_info, dict):
+            return {"email": current_email or None, "nick_name": current_name or None}
+        resolved_email = str(user_info.get("email") or "").strip() or None
+        resolved_name = str(user_info.get("nickName") or user_info.get("displayName") or user_info.get("name") or "").strip() or None
+        return {"email": resolved_email, "nick_name": resolved_name}
+
     def _attach_app_to_package(self, *, profile: str, app_key: str, app_title: str, package_tag_id: int) -> None:
         detail = self.packages.package_get(profile=profile, tag_id=package_tag_id, include_raw=True)
         result = detail.get("result") if isinstance(detail.get("result"), dict) else {}
@@ -1619,18 +2301,49 @@ def _failed_from_api_error(
     suggested_next_call: JSONObject | None = None,
     recoverable: bool = True,
 ) -> JSONObject:
+    effective_error_code = "APP_EDIT_LOCKED" if error.backend_code == 40074 else error_code
+    public_message = _public_error_message(effective_error_code, error)
+    public_http_status = None if error.http_status == 404 else error.http_status
+    merged_details = dict(details or {})
+    if error.backend_code == 40074:
+        owner = _extract_edit_lock_owner(error.message)
+        merged_details.setdefault("lock_owner_name", owner.get("lock_owner_name"))
+        merged_details.setdefault("lock_owner_email", owner.get("lock_owner_email"))
+        app_key = None
+        if isinstance(normalized_args, dict):
+            app_key = normalized_args.get("app_key")
+        if not app_key and isinstance(details, dict):
+            app_key = details.get("app_key")
+        if isinstance(app_key, str) and app_key.strip():
+            suggested_next_call = {
+                "tool_name": "app_release_edit_lock_if_mine",
+                "arguments": {
+                    "app_key": app_key,
+                    "lock_owner_name": owner.get("lock_owner_name") or "",
+                    "lock_owner_email": owner.get("lock_owner_email") or "",
+                },
+            }
+    if error.http_status is not None or error.backend_code is not None:
+        merged_details.setdefault(
+            "transport_error",
+            {
+                "http_status": error.http_status,
+                "backend_code": error.backend_code,
+                "category": error.category,
+            },
+        )
     return _failed(
-        error_code,
-        error.message,
+        effective_error_code,
+        public_message,
         recoverable=recoverable,
         normalized_args=normalized_args,
         missing_fields=missing_fields,
         allowed_values=allowed_values,
-        details=details,
+        details=merged_details,
         suggested_next_call=suggested_next_call,
         request_id=error.request_id,
         backend_code=error.backend_code,
-        http_status=error.http_status,
+        http_status=public_http_status,
     )
 
 
@@ -1669,6 +2382,52 @@ def _coerce_api_error(error: Exception) -> QingflowApiError:
     return QingflowApiError(category="runtime", message=str(error))
 
 
+def _public_error_message(error_code: str, error: QingflowApiError) -> str:
+    if error.backend_code == 40074 or error_code == "APP_EDIT_LOCKED":
+        owner = _extract_edit_lock_owner(error.message)
+        owner_label = owner.get("lock_owner_email") or owner.get("lock_owner_name")
+        if owner_label:
+            return f"app is currently locked by active editor {owner_label}"
+        return "app is currently locked by another active editor session"
+    if error.http_status != 404:
+        return error.message
+    mapping = {
+        "APP_READ_FAILED": "app base or schema is unavailable in the current route",
+        "FIELDS_READ_FAILED": "app fields are unavailable in the current route",
+        "LAYOUT_READ_FAILED": "layout resource is unavailable for this app in the current route",
+        "VIEWS_READ_FAILED": "views resource is unavailable for this app in the current route",
+        "FLOW_READ_FAILED": "workflow resource is unavailable for this app in the current route",
+        "SCHEMA_READBACK_FAILED": "schema was written but schema readback is unavailable in the current route",
+        "CREATE_APP_ROUTE_NOT_FOUND": "create app route is unavailable in the current workspace route",
+        "APP_CREATE_READBACK_FAILED": "app was created but base readback is unavailable in the current route",
+        "PACKAGE_ATTACH_FAILED": "package attachment could not be verified in the current route",
+        "PUBLISH_FAILED": "publish route is unavailable in the current route",
+        "VIEW_APPLY_FAILED": "view resource rejected the operation or is unavailable in the current route",
+        "LAYOUT_APPLY_FAILED": "layout resource rejected the operation or is unavailable in the current route",
+        "SCHEMA_APPLY_FAILED": "schema resource rejected the operation or is unavailable in the current route",
+        "EDIT_LOCK_RELEASE_FAILED": "edit lock release route is unavailable in the current route",
+    }
+    return mapping.get(error_code, "requested builder resource is unavailable in the current route")
+
+
+def _extract_edit_lock_owner(message: str) -> JSONObject:
+    text = str(message or "").strip()
+    if not text:
+        return {"lock_owner_name": None, "lock_owner_email": None}
+    patterns = [
+        r"应用已被\s*(?P<name>[^（(]+?)\s*[（(](?P<email>[^）)]+)[）)]\s*编辑",
+        r"edited by\s*(?P<name>[^<(]+?)\s*<(?P<email>[^>]+)>",
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, text)
+        if match:
+            return {
+                "lock_owner_name": match.groupdict().get("name", "").strip() or None,
+                "lock_owner_email": match.groupdict().get("email", "").strip() or None,
+            }
+    return {"lock_owner_name": None, "lock_owner_email": None}
+
+
 def _coerce_positive_int(value: Any) -> int | None:
     if isinstance(value, bool) or value is None:
         return None
@@ -1696,6 +2455,34 @@ def _coerce_int_list(values: Any) -> list[int]:
     return result
 
 
+def _normalize_view_collection(values: Any) -> list[dict[str, Any]]:
+    if isinstance(values, list):
+        return [item for item in values if isinstance(item, dict)]
+    if isinstance(values, dict):
+        for key in ("list", "viewList", "views", "result"):
+            candidate = values.get(key)
+            if isinstance(candidate, list):
+                return [item for item in candidate if isinstance(item, dict)]
+    return []
+
+
+def _is_view_collection_shape(values: Any) -> bool:
+    if isinstance(values, list):
+        return True
+    if isinstance(values, dict):
+        return any(isinstance(values.get(key), list) for key in ("list", "viewList", "views", "result"))
+    return False
+
+
+def _empty_schema_result(title: str) -> dict[str, Any]:
+    return {
+        "formTitle": title,
+        "editVersionNo": 1,
+        "formQues": [],
+        "questionRelations": [],
+    }
+
+
 def _slugify(text: str, *, default: str) -> str:
     normalized = "".join(ch.lower() if ch.isalnum() else "_" for ch in str(text or ""))
     collapsed = "_".join(part for part in normalized.split("_") if part)
@@ -2377,19 +3164,17 @@ def _build_view_create_payload(
     payload["auth"] = default_member_auth()
     payload.setdefault("sortType", "defaultSort")
     payload.setdefault("viewgraphSorts", [{"queId": 0, "beingSortAscend": True, "queType": 8}])
-    payload.setdefault("beingPinNavigate", True)
-    payload.setdefault("beingShowCover", False)
-    payload.setdefault("defaultRowHigh", "compact")
-    payload.setdefault("asosChartVisible", False)
-    payload.setdefault("viewgraphLimitType", 1)
-    payload.setdefault("viewgraphLimit", [])
-    payload.setdefault("buttonConfigDTOList", [])
     if patch.type.value in {"card", "board"}:
         payload["beingShowTitleQue"] = True
         payload["titleQue"] = visible_que_ids[0] if visible_que_ids else None
     if patch.type.value == "board":
         payload["groupQueId"] = field_map.get(patch.group_by or "")
-    return payload
+    return _hydrate_view_backend_payload(
+        payload=payload,
+        view_type=patch.type.value,
+        visible_que_id_values=visible_que_ids,
+        group_que_id=field_map.get(patch.group_by or "") if patch.group_by else None,
+    )
 
 
 def _build_form_payload_from_existing_schema(
@@ -2581,7 +3366,109 @@ def _build_view_update_payload(
         payload["beingShowTitleQue"] = True
         payload["titleQue"] = visible_que_id_values[0] if visible_que_id_values else None
         payload["groupQueId"] = field_map.get(patch.group_by or "")
-    return payload
+    return _hydrate_view_backend_payload(
+        payload=payload,
+        view_type=normalized_type,
+        visible_que_id_values=visible_que_id_values,
+        group_que_id=field_map.get(patch.group_by or "") if patch.group_by else None,
+    )
+
+
+def _build_minimal_view_payload(
+    *,
+    app_key: str,
+    schema: dict[str, Any],
+    patch: ViewUpsertPatch,
+    ordinal: int,
+) -> JSONObject:
+    field_map = extract_field_map(schema)
+    visible_que_id_values = [field_map[name] for name in patch.columns if name in field_map]
+    payload: JSONObject = {
+        "appKey": app_key,
+        "viewgraphName": patch.name,
+        "viewgraphType": {
+            "table": "tableView",
+            "card": "cardView",
+            "board": "boardView",
+        }[patch.type.value],
+        "ordinal": ordinal,
+        "viewgraphQueIds": visible_que_id_values,
+        "viewgraphQuestions": _build_viewgraph_questions(schema, visible_que_id_values),
+        "auth": default_member_auth(),
+    }
+    if patch.type.value in {"card", "board"}:
+        payload["beingShowTitleQue"] = True
+        payload["titleQue"] = visible_que_id_values[0] if visible_que_id_values else None
+    if patch.type.value == "board":
+        payload["groupQueId"] = field_map.get(patch.group_by or "")
+    return _hydrate_view_backend_payload(
+        payload=payload,
+        view_type=patch.type.value,
+        visible_que_id_values=visible_que_id_values,
+        group_que_id=field_map.get(patch.group_by or "") if patch.group_by else None,
+    )
+
+
+def _hydrate_view_backend_payload(
+    *,
+    payload: JSONObject,
+    view_type: str,
+    visible_que_id_values: list[int],
+    group_que_id: int | None,
+) -> JSONObject:
+    data = deepcopy(payload)
+    data.setdefault("beingPinNavigate", True)
+    data.setdefault("beingNeedPass", False)
+    data.setdefault("beingShowTitleQue", view_type in {"card", "board"})
+    data.setdefault("beingShowCover", False)
+    data.setdefault("defaultRowHigh", "compact")
+    data.setdefault("asosChartVisible", False)
+    data.setdefault("viewgraphPass", "")
+    data.setdefault("beingGroupColor", False)
+    data.setdefault("beingShowQueTitle", True)
+    data.setdefault("beingImageAdaption", False)
+    data.setdefault("clippingMode", "default")
+    data.setdefault("frontCoverQueId", None)
+    data.setdefault("viewgraphLimitType", 1)
+    data.setdefault("viewgraphLimit", [])
+    data.setdefault("viewgraphLimitFormula", "")
+    data.setdefault("sortType", "defaultSort")
+    if not data.get("viewgraphSorts"):
+        sort_que_id = visible_que_id_values[0] if visible_que_id_values else 1
+        data["viewgraphSorts"] = [{"queId": sort_que_id, "beingSortAscend": True}]
+    data.setdefault("beingAuditRecordVisible", True)
+    data.setdefault("beingQrobotRecordVisible", False)
+    data.setdefault("beingPrintStatus", False)
+    data.setdefault("beingDefaultPrintTplStatus", False)
+    data.setdefault("printTpls", [])
+    data.setdefault("beingCommentStatus", False)
+    data.setdefault("usages", [])
+    data.setdefault("dataPermissionType", "CUSTOM")
+    data.setdefault("dataScope", "ALL")
+    data.setdefault("needPass", False)
+    data.setdefault("beingWorkflowNodeFutureListVisible", True)
+    data.setdefault("asosChartConfig", {"limitType": 1, "asosChartIdList": []})
+    data.setdefault("viewgraphGanttConfigVO", None)
+    data.setdefault("viewgraphHierarchyConfigVO", None)
+    data.setdefault("buttonConfigDTOList", [])
+    if "buttonConfig" not in data:
+        data["buttonConfig"] = {"topButtonList": [], "mainButtonDetailList": [], "moreButtonDetailList": []}
+    if view_type == "table":
+        data["viewgraphType"] = "tableView"
+        data["beingShowTitleQue"] = False
+        data["titleQue"] = None
+        data["groupQueId"] = None
+    elif view_type == "card":
+        data["viewgraphType"] = "cardView"
+        data["beingShowTitleQue"] = True
+        data["titleQue"] = visible_que_id_values[0] if visible_que_id_values else None
+        data["groupQueId"] = None
+    elif view_type == "board":
+        data["viewgraphType"] = "boardView"
+        data["beingShowTitleQue"] = True
+        data["titleQue"] = visible_que_id_values[0] if visible_que_id_values else None
+        data["groupQueId"] = group_que_id
+    return data
 
 
 def _infer_status_field_id(fields: list[dict[str, Any]]) -> str | None:
@@ -2615,6 +3502,7 @@ def _normalize_flow_stage_failure(stage: JSONObject, *, profile: str, app_key: s
             request_id = first_error.get("request_id")
             backend_code = first_error.get("backend_code")
             http_status = first_error.get("http_status")
+    lowered_detail = detail_text.lower()
     if "must declare status field" in detail_text:
         return _failed(
             "STATUS_FIELD_REQUIRED",
@@ -2647,14 +3535,45 @@ def _normalize_flow_stage_failure(stage: JSONObject, *, profile: str, app_key: s
             backend_code=backend_code,
             http_status=http_status,
         )
+    if (
+        "run solution_build_app first" in lowered_detail
+        or "run solution_build_app_flow first" in lowered_detail
+        or ("is not defined yet" in lowered_detail and "solution_build_" in lowered_detail)
+    ):
+        return _failed(
+            "FLOW_STAGE_CONTEXT_MISSING",
+            "workflow apply lost the app context required by the internal flow builder",
+            details={
+                "app_key": app_key,
+                "entity_id": entity.get("entity_id"),
+                "existing_fields": entity.get("fields") or [],
+                "internal_detail": detail_text,
+                "stage_result": public_stage_result,
+            },
+            suggested_next_call={"tool_name": "app_flow_plan", "arguments": {"profile": profile, "app_key": app_key}},
+            request_id=request_id,
+            backend_code=backend_code,
+            http_status=http_status,
+        )
+    message = detail_text or "failed to apply workflow patch"
+    details = {"app_key": app_key, "entity_id": entity.get("entity_id"), "stage_result": public_stage_result}
+    public_http_status = http_status
+    if http_status == 404:
+        message = "workflow write route is unavailable for this app in the current route"
+        details["transport_error"] = {
+            "http_status": http_status,
+            "backend_code": backend_code,
+            "category": "http",
+        }
+        public_http_status = None
     return _failed(
         stage_error_code,
-        detail_text or "failed to apply workflow patch",
-        details={"app_key": app_key, "entity_id": entity.get("entity_id"), "stage_result": public_stage_result},
+        message,
+        details=details,
         suggested_next_call={"tool_name": "app_flow_plan", "arguments": {"profile": profile, "app_key": app_key}},
         request_id=request_id,
         backend_code=backend_code,
-        http_status=http_status,
+        http_status=public_http_status,
     )