@qingflow-tech/qingflow-cli 1.1.2 → 1.1.34

package/src/qingflow_mcp/tools/ai_builder_tools.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from copy import deepcopy
 import json
 import time
@@ -15,7 +16,7 @@ from ..builder_facade.button_style_catalog import (
 )
 from ..public_surface import public_builder_contract_tool_names
 from ..config import DEFAULT_PROFILE
-from ..errors import QingflowApiError, backend_code_int
+from ..errors import QingflowApiError, backend_code_int, backend_code_value_int
 from ..json_types import JSONObject
 from ..builder_facade.models import (
     AssociatedResourcesApplyRequest,
@@ -27,6 +28,10 @@ from ..builder_facade.models import (
     FieldPatch,
     FieldRemovePatch,
     FieldUpdatePatch,
+    FlowPreset,
+    FlowNodePatch,
+    FlowPlanRequest,
+    FlowTransitionPatch,
     LayoutApplyMode,
     LayoutPlanRequest,
     LayoutPreset,
@@ -45,6 +50,8 @@ from ..builder_facade.models import (
     ViewUpsertPatch,
     ViewsPreset,
     ViewsPlanRequest,
+    public_view_partial_payload,
+    public_view_upsert_payload,
 )
 from ..builder_facade.service import AiBuilderFacade, INTEGRATION_OUTPUT_TARGET_FIELD_TYPES
 from ..solution.compiler.icon_utils import (
@@ -66,6 +73,7 @@ from .qingbi_report_tools import QingbiReportTools
 from .role_tools import RoleTools
 from .solution_tools import SolutionTools
 from .view_tools import ViewTools
+from .workflow_tools import WorkflowTools
 
 
 def _normalize_builder_view_key(value: str) -> str:
@@ -75,6 +83,52 @@ def _normalize_builder_view_key(value: str) -> str:
     return raw
 
 
+def _payload_get(payload: JSONObject, *keys: str, default: Any = None) -> Any:
+    for key in keys:
+        if key in payload:
+            return payload.get(key)
+    return default
+
+
+def _payload_list(payload: JSONObject, *keys: str, default: list | None = None) -> list:
+    value = _payload_get(payload, *keys, default=default if default is not None else [])
+    return value if isinstance(value, list) else []
+
+
+def _payload_bool(payload: JSONObject, *keys: str, default: bool = True) -> bool:
+    value = _payload_get(payload, *keys, default=default)
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        normalized = value.strip().lower()
+        if normalized in {"1", "true", "yes", "y", "on"}:
+            return True
+        if normalized in {"0", "false", "no", "n", "off"}:
+            return False
+    return bool(value)
+
+
+def _elapsed_ms(started_at: float) -> int:
+    return max(0, int((time.perf_counter() - started_at) * 1000))
+
+
+def _merge_duration_breakdown(payload: JSONObject, **items: int | None) -> None:
+    breakdown = payload.get("duration_breakdown_ms")
+    if not isinstance(breakdown, dict):
+        breakdown = {}
+        payload["duration_breakdown_ms"] = breakdown
+    for key, value in items.items():
+        if value is None:
+            continue
+        breakdown[key] = int(value)
+
+
+def _inline_form_layout_was_handled(payload: JSONObject) -> bool:
+    inline_layout = payload.get("inline_form_layout")
+    return isinstance(inline_layout, dict) and bool(inline_layout.get("requested"))
+
+
+PUBLIC_STABLE_FLOW_NODE_TYPES = ["start", "approve", "fill", "copy", "webhook", "end"]
 BUILDER_APPLY_SCHEMA_VERSION = "builder.apply.v1"
 BUILDER_APPLY_TOOL_NAMES = {
     "package_apply",
@@ -89,6 +143,9 @@ BUILDER_APPLY_TOOL_NAMES = {
     "portal_delete",
     "app_publish_verify",
 }
+MULTI_APP_SCHEMA_APPLY_PARALLEL_LIMIT = 10
+VIEW_APPLY_PARALLEL_LIMIT = 20
+PORTAL_INLINE_CHART_MAX_WORKERS = 10
 
 
 class AiBuilderTools(ToolBase):
@@ -109,6 +166,7 @@ class AiBuilderTools(ToolBase):
             buttons=CustomButtonTools(sessions, backend),
             packages=PackageTools(sessions, backend),
             views=ViewTools(sessions, backend),
+            workflows=WorkflowTools(sessions, backend),
             portals=PortalTools(sessions, backend),
             charts=QingbiReportTools(sessions, backend),
             roles=RoleTools(sessions, backend),
@@ -116,6 +174,193 @@ class AiBuilderTools(ToolBase):
             solutions=SolutionTools(sessions, backend),
         )
 
+    def _apply_app_batch(self, *, tool_name: str, profile: str, apps: list[JSONObject], apply_one) -> JSONObject:
+        started_at = time.perf_counter()
+        batch_item_apply_ms = 0
+        child_total_ms = 0
+
+        def finish(payload: JSONObject) -> JSONObject:
+            _merge_duration_breakdown(
+                payload,
+                batch_item_apply_ms=batch_item_apply_ms,
+                child_total_ms=child_total_ms,
+                total_ms=_elapsed_ms(started_at),
+            )
+            return _attach_builder_apply_envelope(tool_name, payload)
+
+        if not isinstance(apps, list) or not apps:
+            return finish(
+                _config_failure(
+                    tool_name=tool_name,
+                    message=f"{tool_name} batch mode requires non-empty apps[].",
+                    fix_hint="Pass apps as a JSON array; each item must include app_key plus that resource's normal payload.",
+                    details={"expected_shape": {"apps": [{"app_key": "APP_KEY"}]}},
+                )
+            )
+
+        app_results: list[JSONObject] = []
+        errors: list[JSONObject] = []
+        for index, item in enumerate(apps):
+            if not isinstance(item, dict):
+                error = {
+                    "index": index,
+                    "status": "failed",
+                    "error_code": "APPS_FILE_ITEM_INVALID",
+                    "message": "apps[] item must be an object",
+                    "reason_path": f"apps[{index}]",
+                }
+                errors.append(error)
+                app_results.append(error)
+                continue
+            app_key = str(item.get("app_key") or item.get("appKey") or "").strip()
+            if not app_key:
+                error = {
+                    "index": index,
+                    "status": "failed",
+                    "error_code": "APPS_FILE_APP_KEY_REQUIRED",
+                    "message": "apps[] item requires app_key",
+                    "reason_path": f"apps[{index}].app_key",
+                }
+                errors.append(error)
+                app_results.append(error)
+                continue
+            try:
+                item_started_at = time.perf_counter()
+                result = apply_one(index, item, app_key)
+            except (QingflowApiError, RuntimeError) as error:
+                batch_item_apply_ms += _elapsed_ms(item_started_at)
+                api_error = _coerce_api_error(error)
+                result = {
+                    "status": "failed",
+                    "error_code": f"{tool_name.upper()}_BATCH_ITEM_FAILED",
+                    "recoverable": True,
+                    "message": _public_error_message(f"{tool_name.upper()}_BATCH_ITEM_FAILED", api_error),
+                    "app_key": app_key,
+                    "normalized_args": {"app_key": app_key},
+                    "details": {"transport_error": _transport_error_payload(api_error)},
+                    "request_id": api_error.request_id,
+                    "backend_code": api_error.backend_code,
+                    "http_status": None if api_error.http_status == 404 else api_error.http_status,
+                }
+            else:
+                batch_item_apply_ms += _elapsed_ms(item_started_at)
+            if isinstance(result, dict):
+                child_breakdown = result.get("duration_breakdown_ms")
+                child_total = child_breakdown.get("total_ms") if isinstance(child_breakdown, dict) else None
+                if isinstance(child_total, (int, float)) and child_total >= 0:
+                    child_total_ms += int(child_total)
+            status = str(result.get("status") or "success") if isinstance(result, dict) else "failed"
+            wrapped: JSONObject = {
+                "index": index,
+                "app_key": app_key,
+                "status": status,
+                "result": result if isinstance(result, dict) else {"status": "failed", "message": str(result)},
+            }
+            if status == "failed":
+                error = {
+                    "index": index,
+                    "app_key": app_key,
+                    "status": status,
+                    "error_code": wrapped["result"].get("error_code"),
+                    "message": wrapped["result"].get("message"),
+                }
+                errors.append(error)
+                wrapped["error"] = error
+            app_results.append(wrapped)
+
+        partial = sum(1 for item in app_results if str(item.get("status") or "") == "partial_success")
+        succeeded = sum(1 for item in app_results if str(item.get("status") or "") in {"success", "partial_success"})
+        failed = len(app_results) - succeeded
+        status = "failed" if succeeded == 0 else "partial_success" if failed > 0 or partial > 0 else "success"
+        write_executed = any(
+            isinstance(item.get("result"), dict) and bool(item["result"].get("write_executed"))
+            for item in app_results
+        )
+        payload: JSONObject = {
+            "status": status,
+            "error_code": None if status == "success" else f"{tool_name.upper()}_BATCH_PARTIAL" if succeeded else f"{tool_name.upper()}_BATCH_FAILED",
+            "recoverable": failed > 0 or partial > 0,
+            "message": (
+                f"applied {tool_name} to {succeeded}/{len(app_results)} apps"
+                if status != "success"
+                else f"applied {tool_name} to {succeeded} apps"
+            ),
+            "normalized_args": {"apps": apps},
+            "apps": app_results,
+            "errors": errors,
+            "verification": {
+                "batch_verified": failed == 0 and partial == 0,
+                "succeeded": succeeded,
+                "partial": partial,
+                "failed": failed,
+            },
+            "write_executed": write_executed,
+            "write_succeeded": write_executed and failed == 0 and partial == 0,
+            "safe_to_retry": not write_executed,
+        }
+        return finish(payload)
+
+    def _read_app_batch(self, *, tool_name: str, profile: str, app_keys: list[str], read_one) -> JSONObject:
+        normalized_keys = [str(item).strip() for item in app_keys if str(item).strip()]
+        if not normalized_keys:
+            return _config_failure(
+                tool_name=tool_name,
+                message=f"{tool_name} batch mode requires non-empty app_keys[].",
+                fix_hint="Pass app_keys as a non-empty list of app keys.",
+                details={"expected_shape": {"app_keys": ["APP_A", "APP_B"]}},
+            )
+        apps: list[JSONObject] = []
+        errors: list[JSONObject] = []
+        for index, app_key in enumerate(normalized_keys):
+            try:
+                result = read_one(app_key)
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = _coerce_api_error(error)
+                result = {
+                    "status": "failed",
+                    "error_code": f"{tool_name.upper()}_BATCH_ITEM_FAILED",
+                    "recoverable": True,
+                    "message": _public_error_message(f"{tool_name.upper()}_BATCH_ITEM_FAILED", api_error),
+                    "app_key": app_key,
+                    "details": {"transport_error": _transport_error_payload(api_error)},
+                    "request_id": api_error.request_id,
+                    "backend_code": api_error.backend_code,
+                    "http_status": None if api_error.http_status == 404 else api_error.http_status,
+                }
+            status = str(result.get("status") or "success") if isinstance(result, dict) else "failed"
+            app_item: JSONObject = {
+                "index": index,
+                "app_key": app_key,
+                "status": status,
+                "data": result,
+            }
+            if status == "failed":
+                error = {
+                    "index": index,
+                    "app_key": app_key,
+                    "status": "failed",
+                    "error_code": result.get("error_code") if isinstance(result, dict) else None,
+                    "message": result.get("message") if isinstance(result, dict) else str(result),
+                }
+                app_item["error"] = error
+                errors.append(error)
+            apps.append(app_item)
+        partial = sum(1 for item in apps if str(item.get("status") or "") == "partial_success")
+        succeeded = sum(1 for item in apps if str(item.get("status") or "") in {"success", "partial_success"})
+        failed = len(apps) - succeeded
+        status = "failed" if succeeded == 0 else "partial_success" if failed > 0 or partial > 0 else "success"
+        return {
+            "status": status,
+            "error_code": None if status == "success" else f"{tool_name.upper()}_BATCH_PARTIAL" if succeeded else f"{tool_name.upper()}_BATCH_FAILED",
+            "recoverable": failed > 0 or partial > 0,
+            "message": f"read {tool_name} for {succeeded}/{len(apps)} apps" if status != "success" else f"read {tool_name} for {succeeded} apps",
+            "normalized_args": {"app_keys": normalized_keys},
+            "app_keys": normalized_keys,
+            "apps": apps,
+            "errors": errors,
+            "verification": {"batch_verified": failed == 0 and partial == 0, "succeeded": succeeded, "partial": partial, "failed": failed},
+        }
+
     def register(self, mcp) -> None:
         """注册当前工具到 MCP 服务。"""
         @mcp.tool()
@@ -139,7 +384,6 @@ class AiBuilderTools(ToolBase):
             profile: str = DEFAULT_PROFILE,
             package_id: int | None = None,
             package_name: str | None = None,
-            create_if_missing: bool = False,
             icon: str | JSONObject | None = None,
             color: str | None = None,
             icon_name: str | None = None,
@@ -153,7 +397,6 @@ class AiBuilderTools(ToolBase):
                 profile=profile,
                 package_id=package_id,
                 package_name=package_name,
-                create_if_missing=create_if_missing,
                 icon=icon,
                 color=color,
                 icon_name=icon_name,
@@ -271,6 +514,7 @@ class AiBuilderTools(ToolBase):
             patch_buttons: list[JSONObject] | None = None,
             remove_buttons: list[JSONObject] | None = None,
             view_configs: list[JSONObject] | None = None,
+            apps: list[JSONObject] | None = None,
         ) -> JSONObject:
             return self.app_custom_buttons_apply(
                 profile=profile,
@@ -279,6 +523,7 @@ class AiBuilderTools(ToolBase):
                 patch_buttons=patch_buttons or [],
                 remove_buttons=remove_buttons or [],
                 view_configs=view_configs or [],
+                apps=apps,
             )
 
         @mcp.tool()
@@ -290,6 +535,7 @@ class AiBuilderTools(ToolBase):
             remove_associated_item_ids: list[int] | None = None,
             reorder_associated_item_ids: list[int] | None = None,
             view_configs: list[JSONObject] | None = None,
+            apps: list[JSONObject] | None = None,
         ) -> JSONObject:
             return self.app_associated_resources_apply(
                 profile=profile,
@@ -299,15 +545,16 @@ class AiBuilderTools(ToolBase):
                 remove_associated_item_ids=remove_associated_item_ids or [],
                 reorder_associated_item_ids=reorder_associated_item_ids or [],
                 view_configs=view_configs or [],
+                apps=apps,
             )
 
         @mcp.tool()
-        def app_get(profile: str = DEFAULT_PROFILE, app_key: str = "") -> JSONObject:
-            return self.app_get(profile=profile, app_key=app_key)
+        def app_get(profile: str = DEFAULT_PROFILE, app_key: str = "", app_keys: list[str] | None = None) -> JSONObject:
+            return self.app_get(profile=profile, app_key=app_key, app_keys=app_keys)
 
         @mcp.tool()
-        def app_get_fields(profile: str = DEFAULT_PROFILE, app_key: str = "") -> JSONObject:
-            return self.app_get_fields(profile=profile, app_key=app_key)
+        def app_get_fields(profile: str = DEFAULT_PROFILE, app_key: str = "", app_keys: list[str] | None = None) -> JSONObject:
+            return self.app_get_fields(profile=profile, app_key=app_key, app_keys=app_keys)
 
         @mcp.tool()
         def app_repair_code_blocks(
@@ -319,20 +566,28 @@ class AiBuilderTools(ToolBase):
             return self.app_repair_code_blocks(profile=profile, app_key=app_key, field=field, apply=apply)
 
         @mcp.tool()
-        def app_get_layout(profile: str = DEFAULT_PROFILE, app_key: str = "") -> JSONObject:
-            return self.app_get_layout(profile=profile, app_key=app_key)
+        def app_get_layout(profile: str = DEFAULT_PROFILE, app_key: str = "", app_keys: list[str] | None = None) -> JSONObject:
+            return self.app_get_layout(profile=profile, app_key=app_key, app_keys=app_keys)
+
+        @mcp.tool()
+        def app_get_views(profile: str = DEFAULT_PROFILE, app_key: str = "", app_keys: list[str] | None = None) -> JSONObject:
+            return self.app_get_views(profile=profile, app_key=app_key, app_keys=app_keys)
 
         @mcp.tool()
-        def app_get_views(profile: str = DEFAULT_PROFILE, app_key: str = "") -> JSONObject:
-            return self.app_get_views(profile=profile, app_key=app_key)
+        def app_get_flow(profile: str = DEFAULT_PROFILE, app_key: str = "", app_keys: list[str] | None = None) -> JSONObject:
+            return self.app_get_flow(profile=profile, app_key=app_key, app_keys=app_keys)
 
         @mcp.tool()
-        def app_get_flow(profile: str = DEFAULT_PROFILE, app_key: str = "") -> JSONObject:
-            return self.app_get_flow(profile=profile, app_key=app_key)
+        def app_get_charts(profile: str = DEFAULT_PROFILE, app_key: str = "", app_keys: list[str] | None = None) -> JSONObject:
+            return self.app_get_charts(profile=profile, app_key=app_key, app_keys=app_keys)
 
         @mcp.tool()
-        def app_get_charts(profile: str = DEFAULT_PROFILE, app_key: str = "") -> JSONObject:
-            return self.app_get_charts(profile=profile, app_key=app_key)
+        def app_get_buttons(profile: str = DEFAULT_PROFILE, app_key: str = "", app_keys: list[str] | None = None) -> JSONObject:
+            return self.app_get_buttons(profile=profile, app_key=app_key, app_keys=app_keys)
+
+        @mcp.tool()
+        def app_get_associated_resources(profile: str = DEFAULT_PROFILE, app_key: str = "", app_keys: list[str] | None = None) -> JSONObject:
+            return self.app_get_associated_resources(profile=profile, app_key=app_key, app_keys=app_keys)
 
         @mcp.tool()
         def portal_list(profile: str = DEFAULT_PROFILE) -> JSONObject:
@@ -370,19 +625,19 @@ class AiBuilderTools(ToolBase):
             icon_color: str | None = None,
             icon_config: JSONObject | None = None,
             visibility: JSONObject | None = None,
-            create_if_missing: bool = False,
             publish: bool = True,
+            form: list[JSONObject] | None = None,
             add_fields: list[JSONObject] | None = None,
             update_fields: list[JSONObject] | None = None,
             remove_fields: list[JSONObject] | None = None,
             apps: list[JSONObject] | None = None,
         ) -> JSONObject:
             if apps is not None:
-                if app_key or app_name or app_title or add_fields or update_fields or remove_fields:
+                if app_key or app_name or app_title or form or add_fields or update_fields or remove_fields:
                     return _config_failure(
                         tool_name="app_schema_apply",
-                        message="app_schema_apply multi-app mode accepts package_id/create_if_missing plus apps only.",
-                        fix_hint="Use `apps` for batch mode, or use the single-app arguments without `apps`.",
+                        message="app_schema_apply multi-app mode accepts package_id plus apps only.",
+                        fix_hint="Put per-app form in apps[].form when using batch mode.",
                     )
                 if package_id is None:
                     return _config_failure(
@@ -394,9 +649,9 @@ class AiBuilderTools(ToolBase):
                     profile=profile,
                     package_id=package_id,
                     visibility=visibility,
-                    create_if_missing=create_if_missing,
                     publish=publish,
                     apps=apps,
+                    form=None,
                     add_fields=[],
                     update_fields=[],
                     remove_fields=[],
@@ -406,18 +661,18 @@ class AiBuilderTools(ToolBase):
             has_app_title = bool((app_title or "").strip())
             has_package_id = package_id is not None
             if has_app_key:
-                if create_if_missing or has_package_id:
+                if has_package_id:
                     return _config_failure(
                         tool_name="app_schema_apply",
                         message="app_schema_apply edit mode accepts app_key and optional app_name rename only.",
-                        fix_hint="For existing apps, use `app_key` and optionally `app_name`. For create mode, use `package_id + app_name + create_if_missing=true`.",
+                        fix_hint="For existing apps, use `app_key` and optionally `app_name`. For create mode, use `package_id + app_name`.",
                     )
-            elif not (create_if_missing and has_package_id and (has_app_name or has_app_title)):
+            elif not (has_package_id and (has_app_name or has_app_title)):
                 return _config_failure(
                     tool_name="app_schema_apply",
-                    message="app_schema_apply create mode requires package_id, app_name, and create_if_missing=true.",
-                    fix_hint="Use `app_key` for existing apps, or pass `package_id + app_name + create_if_missing=true` to create a new app.",
-                )
+                    message="app_schema_apply create mode requires package_id and app_name.",
+                        fix_hint="Use `app_key` for existing apps, or pass `package_id + app_name` to create a new app.",
+                    )
             return self.app_schema_apply(
                 profile=profile,
                 app_key=app_key,
@@ -430,12 +685,12 @@ class AiBuilderTools(ToolBase):
                 icon_color=icon_color,
                 icon_config=icon_config,
                 visibility=visibility,
-                create_if_missing=create_if_missing,
                 publish=publish,
+                form=form or [],
                 add_fields=add_fields or [],
                 update_fields=update_fields or [],
                 remove_fields=remove_fields or [],
-                apps=[],
+                apps=None,
             )
 
         @mcp.tool()
@@ -445,8 +700,9 @@ class AiBuilderTools(ToolBase):
             mode: str = "merge",
             publish: bool = True,
             sections: list[JSONObject] | None = None,
+            apps: list[JSONObject] | None = None,
         ) -> JSONObject:
-            return self.app_layout_apply(profile=profile, app_key=app_key, mode=mode, publish=publish, sections=sections or [])
+            return self.app_layout_apply(profile=profile, app_key=app_key, mode=mode, publish=publish, sections=sections or [], apps=apps)
 
         @mcp.tool()
         def app_flow_get(
@@ -454,7 +710,7 @@ class AiBuilderTools(ToolBase):
             app_key: str = "",
             version_id: str = "",
         ) -> JSONObject:
-            return self.app_get_flow(profile=profile, app_key=app_key, version_id=version_id or None)
+            return self.app_flow_get(profile=profile, app_key=app_key, version_id=version_id or None)
 
         @mcp.tool()
         def app_flow_get_schema(profile: str = DEFAULT_PROFILE, schema_version: str = "") -> JSONObject:
@@ -468,14 +724,16 @@ class AiBuilderTools(ToolBase):
             spec: JSONObject | None = None,
             idempotency_key: str = "",
             schema_version: str = "",
+            patch_nodes: list[JSONObject] | None = None,
         ) -> JSONObject:
             return self.app_flow_apply(
                 profile=profile,
                 app_key=app_key,
                 publish=publish,
-                spec=spec or {},
+                spec=spec,
                 idempotency_key=idempotency_key or None,
                 schema_version=schema_version or None,
+                patch_nodes=patch_nodes,
             )
 
         @mcp.tool()
@@ -486,6 +744,7 @@ class AiBuilderTools(ToolBase):
             upsert_views: list[JSONObject] | None = None,
             patch_views: list[JSONObject] | None = None,
             remove_views: list[str] | None = None,
+            apps: list[JSONObject] | None = None,
         ) -> JSONObject:
             return self.app_views_apply(
                 profile=profile,
@@ -494,6 +753,7 @@ class AiBuilderTools(ToolBase):
                 upsert_views=upsert_views or [],
                 patch_views=patch_views or [],
                 remove_views=remove_views or [],
+                apps=apps,
             )
 
         @mcp.tool()
@@ -504,6 +764,7 @@ class AiBuilderTools(ToolBase):
             patch_charts: list[JSONObject] | None = None,
             remove_chart_ids: list[str] | None = None,
             reorder_chart_ids: list[str] | None = None,
+            apps: list[JSONObject] | None = None,
         ) -> JSONObject:
             return self.app_charts_apply(
                 profile=profile,
@@ -512,6 +773,7 @@ class AiBuilderTools(ToolBase):
                 patch_charts=patch_charts or [],
                 remove_chart_ids=remove_chart_ids or [],
                 reorder_chart_ids=reorder_chart_ids or [],
+                apps=apps,
             )
 
         @mcp.tool()
@@ -533,6 +795,7 @@ class AiBuilderTools(ToolBase):
             dash_global_config: JSONObject | None = None,
             config: JSONObject | None = None,
             payload: JSONObject | None = None,
+            patch_sections: list[JSONObject] | None = None,
         ) -> JSONObject:
             payload = payload if isinstance(payload, dict) else {}
             has_dash_key = bool((dash_key or "").strip())
@@ -570,6 +833,7 @@ class AiBuilderTools(ToolBase):
                 dash_global_config=dash_global_config,
                 config=config or {},
                 payload=payload,
+                patch_sections=patch_sections,
             )
 
         @mcp.tool(description=self._high_risk_tool_description(operation="delete", target="portal"))
@@ -583,11 +847,13 @@ class AiBuilderTools(ToolBase):
         def app_publish_verify(
             profile: str = DEFAULT_PROFILE,
             app_key: str = "",
+            app_keys: list[str] | None = None,
             expected_package_id: int | None = None,
         ) -> JSONObject:
             return self.app_publish_verify(
                 profile=profile,
                 app_key=app_key,
+                app_keys=app_keys,
                 expected_package_id=expected_package_id,
             )
 
@@ -759,7 +1025,6 @@ class AiBuilderTools(ToolBase):
         profile: str,
         package_id: int | None = None,
         package_name: str | None = None,
-        create_if_missing: bool = False,
         icon: str | JSONObject | None = None,
         color: str | None = None,
         icon_name: str | None = None,
@@ -790,14 +1055,13 @@ class AiBuilderTools(ToolBase):
             tool_name="package_apply",
             icon=icon,
             color=color,
-            creating=package_id is None and bool(create_if_missing),
+            creating=package_id is None and bool(str(package_name or "").strip()),
         )
         if icon_failure is not None:
             return _attach_builder_apply_envelope("package_apply", icon_failure)
         normalized_args = {
             "package_id": package_id,
             **({"package_name": package_name} if str(package_name or "").strip() else {}),
-            "create_if_missing": bool(create_if_missing),
             **({"icon": icon} if icon else {}),
             **({"color": color} if color else {}),
             **({"visibility": visibility_patch.model_dump(mode="json")} if visibility_patch is not None else {}),
@@ -809,7 +1073,6 @@ class AiBuilderTools(ToolBase):
                 profile=profile,
                 package_id=package_id,
                 package_name=package_name,
-                create_if_missing=create_if_missing,
                 icon=icon,
                 color=color,
                 visibility=visibility_patch,
@@ -1063,8 +1326,24 @@ class AiBuilderTools(ToolBase):
         patch_buttons: list[JSONObject] | None = None,
         remove_buttons: list[JSONObject],
         view_configs: list[JSONObject] | None = None,
+        apps: list[JSONObject] | None = None,
     ) -> JSONObject:
         """执行应用按钮 apply 逻辑。"""
+        if apps is not None:
+            return self._apply_app_batch(
+                tool_name="app_custom_buttons_apply",
+                profile=profile,
+                apps=apps,
+                apply_one=lambda _index, item, item_app_key: self.app_custom_buttons_apply(
+                    profile=profile,
+                    app_key=item_app_key,
+                    upsert_buttons=_payload_list(item, "upsert_buttons", "upsertButtons", "buttons", default=upsert_buttons or []),
+                    patch_buttons=_payload_list(item, "patch_buttons", "patchButtons", default=patch_buttons or []),
+                    remove_buttons=_payload_list(item, "remove_buttons", "removeButtons", default=remove_buttons or []),
+                    view_configs=_payload_list(item, "view_configs", "viewConfigs", default=view_configs or []),
+                    apps=None,
+                ),
+            )
         raw_request = {
             "app_key": app_key,
             "upsert_buttons": upsert_buttons,
@@ -1117,8 +1396,35 @@ class AiBuilderTools(ToolBase):
         reorder_associated_item_ids: list[int],
         view_configs: list[JSONObject],
         patch_resources: list[JSONObject] | None = None,
+        apps: list[JSONObject] | None = None,
     ) -> JSONObject:
         """执行应用关联资源 apply 逻辑。"""
+        if apps is not None:
+            return self._apply_app_batch(
+                tool_name="app_associated_resources_apply",
+                profile=profile,
+                apps=apps,
+                apply_one=lambda _index, item, item_app_key: self.app_associated_resources_apply(
+                    profile=profile,
+                    app_key=item_app_key,
+                    upsert_resources=_payload_list(item, "upsert_resources", "upsertResources", "resources", default=upsert_resources or []),
+                    patch_resources=_payload_list(item, "patch_resources", "patchResources", default=patch_resources or []),
+                    remove_associated_item_ids=_payload_list(
+                        item,
+                        "remove_associated_item_ids",
+                        "removeAssociatedItemIds",
+                        default=remove_associated_item_ids or [],
+                    ),
+                    reorder_associated_item_ids=_payload_list(
+                        item,
+                        "reorder_associated_item_ids",
+                        "reorderAssociatedItemIds",
+                        default=reorder_associated_item_ids or [],
+                    ),
+                    view_configs=_payload_list(item, "view_configs", "viewConfigs", default=view_configs or []),
+                    apps=None,
+                ),
+            )
         raw_request = {
             "app_key": app_key,
             "upsert_resources": upsert_resources,
@@ -1281,8 +1587,15 @@ class AiBuilderTools(ToolBase):
         ))
 
     @tool_cn_name("应用详情查询")
-    def app_get(self, *, profile: str, app_key: str) -> JSONObject:
+    def app_get(self, *, profile: str, app_key: str, app_keys: list[str] | None = None) -> JSONObject:
         """执行应用相关逻辑。"""
+        if app_keys is not None:
+            return self._read_app_batch(
+                tool_name="app_get",
+                profile=profile,
+                app_keys=app_keys,
+                read_one=lambda item_app_key: self.app_get(profile=profile, app_key=item_app_key, app_keys=None),
+            )
         normalized_args = {"app_key": app_key}
         return _publicize_package_fields(_safe_tool_call(
             lambda: self._facade.app_get(profile=profile, app_key=app_key),
@@ -1303,8 +1616,15 @@ class AiBuilderTools(ToolBase):
         )
 
     @tool_cn_name("应用字段详情查询")
-    def app_get_fields(self, *, profile: str, app_key: str) -> JSONObject:
+    def app_get_fields(self, *, profile: str, app_key: str, app_keys: list[str] | None = None) -> JSONObject:
         """执行应用相关逻辑。"""
+        if app_keys is not None:
+            return self._read_app_batch(
+                tool_name="app_get_fields",
+                profile=profile,
+                app_keys=app_keys,
+                read_one=lambda item_app_key: self.app_get_fields(profile=profile, app_key=item_app_key, app_keys=None),
+            )
         normalized_args = {"app_key": app_key}
         return _safe_tool_call(
             lambda: self._facade.app_get_fields(profile=profile, app_key=app_key),
@@ -1343,8 +1663,15 @@ class AiBuilderTools(ToolBase):
         )
 
     @tool_cn_name("应用布局详情查询")
-    def app_get_layout(self, *, profile: str, app_key: str) -> JSONObject:
+    def app_get_layout(self, *, profile: str, app_key: str, app_keys: list[str] | None = None) -> JSONObject:
         """执行应用相关逻辑。"""
+        if app_keys is not None:
+            return self._read_app_batch(
+                tool_name="app_get_layout",
+                profile=profile,
+                app_keys=app_keys,
+                read_one=lambda item_app_key: self.app_get_layout(profile=profile, app_key=item_app_key, app_keys=None),
+            )
         normalized_args = {"app_key": app_key}
         return _safe_tool_call(
             lambda: self._facade.app_get_layout(profile=profile, app_key=app_key),
@@ -1365,8 +1692,15 @@ class AiBuilderTools(ToolBase):
         )
 
     @tool_cn_name("应用视图详情查询")
-    def app_get_views(self, *, profile: str, app_key: str) -> JSONObject:
+    def app_get_views(self, *, profile: str, app_key: str, app_keys: list[str] | None = None) -> JSONObject:
         """执行应用相关逻辑。"""
+        if app_keys is not None:
+            return self._read_app_batch(
+                tool_name="app_get_views",
+                profile=profile,
+                app_keys=app_keys,
+                read_one=lambda item_app_key: self.app_get_views(profile=profile, app_key=item_app_key, app_keys=None),
+            )
         normalized_args = {"app_key": app_key}
         return _safe_tool_call(
             lambda: self._facade.app_get_views(profile=profile, app_key=app_key),
@@ -1375,25 +1709,53 @@ class AiBuilderTools(ToolBase):
             suggested_next_call={"tool_name": "app_get_views", "arguments": {"profile": profile, "app_key": app_key}},
         )
 
-    @tool_cn_name("Workflow Spec Schema")
-    def app_flow_get_schema(self, *, profile: str, schema_version: str | None = None) -> JSONObject:
-        normalized_args = {"schema_version": schema_version}
+    @tool_cn_name("应用流程摘要读取")
+    def app_read_flow_summary(self, *, profile: str, app_key: str) -> JSONObject:
+        """执行应用相关逻辑。"""
+        normalized_args = {"app_key": app_key}
         return _safe_tool_call(
-            lambda: self._facade.flow_get_schema(profile=profile, schema_version=schema_version),
-            error_code="FLOW_SPEC_SCHEMA_FAILED",
+            lambda: self._facade.app_read_flow_summary(profile=profile, app_key=app_key),
+            error_code="FLOW_READ_FAILED",
             normalized_args=normalized_args,
-            suggested_next_call={"tool_name": "app_flow_get_schema", "arguments": {"profile": profile, **normalized_args}},
+            suggested_next_call={"tool_name": "app_get_flow", "arguments": {"profile": profile, "app_key": app_key}},
         )
 
-    @tool_cn_name("Workflow Spec 读取")
-    def app_get_flow(self, *, profile: str, app_key: str, version_id: str | None = None) -> JSONObject:
+    @tool_cn_name("应用流程详情查询")
+    def app_get_flow(self, *, profile: str, app_key: str, app_keys: list[str] | None = None) -> JSONObject:
         """执行应用相关逻辑。"""
+        if app_keys is not None:
+            return self._read_app_batch(
+                tool_name="app_get_flow",
+                profile=profile,
+                app_keys=app_keys,
+                read_one=lambda item_app_key: self.app_get_flow(profile=profile, app_key=item_app_key, app_keys=None),
+            )
+        normalized_args = {"app_key": app_key}
+        return _safe_tool_call(
+            lambda: self._facade.app_get_flow(profile=profile, app_key=app_key),
+            error_code="APP_GET_FLOW_FAILED",
+            normalized_args=normalized_args,
+            suggested_next_call={"tool_name": "app_get_flow", "arguments": {"profile": profile, "app_key": app_key}},
+        )
+
+    @tool_cn_name("应用流程规格查询")
+    def app_flow_get(self, *, profile: str, app_key: str, version_id: str | None = None) -> JSONObject:
         normalized_args = {"app_key": app_key, "version_id": version_id}
         return _safe_tool_call(
             lambda: self._facade.flow_get(profile=profile, app_key=app_key, version_id=version_id),
-            error_code="APP_GET_FLOW_FAILED",
+            error_code="APP_FLOW_GET_FAILED",
+            normalized_args=normalized_args,
+            suggested_next_call={"tool_name": "app_flow_get", "arguments": {"profile": profile, **normalized_args}},
+        )
+
+    @tool_cn_name("应用流程规格 Schema 查询")
+    def app_flow_get_schema(self, *, profile: str, schema_version: str | None = None) -> JSONObject:
+        normalized_args = {"schema_version": schema_version}
+        return _safe_tool_call(
+            lambda: self._facade.flow_get_schema(profile=profile, schema_version=schema_version),
+            error_code="APP_FLOW_SCHEMA_GET_FAILED",
             normalized_args=normalized_args,
-            suggested_next_call={"tool_name": "app_flow_get", "arguments": {"profile": profile, "app_key": app_key}},
+            suggested_next_call={"tool_name": "app_flow_get_schema", "arguments": {"profile": profile, **normalized_args}},
         )
 
     @tool_cn_name("应用图表摘要读取")
@@ -1408,8 +1770,15 @@ class AiBuilderTools(ToolBase):
         )
 
     @tool_cn_name("应用图表详情查询")
-    def app_get_charts(self, *, profile: str, app_key: str) -> JSONObject:
+    def app_get_charts(self, *, profile: str, app_key: str, app_keys: list[str] | None = None) -> JSONObject:
         """执行应用相关逻辑。"""
+        if app_keys is not None:
+            return self._read_app_batch(
+                tool_name="app_get_charts",
+                profile=profile,
+                app_keys=app_keys,
+                read_one=lambda item_app_key: self.app_get_charts(profile=profile, app_key=item_app_key, app_keys=None),
+            )
         normalized_args = {"app_key": app_key}
         return _safe_tool_call(
             lambda: self._facade.app_get_charts(profile=profile, app_key=app_key),
@@ -1418,6 +1787,40 @@ class AiBuilderTools(ToolBase):
             suggested_next_call={"tool_name": "app_get_charts", "arguments": {"profile": profile, "app_key": app_key}},
         )
 
+    @tool_cn_name("自定义按钮读取")
+    def app_get_buttons(self, *, profile: str, app_key: str = "", app_keys: list[str] | None = None) -> JSONObject:
+        if app_keys is not None:
+            return self._read_app_batch(
+                tool_name="app_get_buttons",
+                profile=profile,
+                app_keys=app_keys,
+                read_one=lambda item_app_key: self.app_get_buttons(profile=profile, app_key=item_app_key, app_keys=None),
+            )
+        normalized_args = {"app_key": app_key}
+        return _safe_tool_call(
+            lambda: self._facade.app_get_buttons(profile=profile, app_key=app_key),
+            error_code="APP_GET_BUTTONS_FAILED",
+            normalized_args=normalized_args,
+            suggested_next_call={"tool_name": "app_get_buttons", "arguments": {"profile": profile, "app_key": app_key}},
+        )
+
+    @tool_cn_name("关联资源读取")
+    def app_get_associated_resources(self, *, profile: str, app_key: str = "", app_keys: list[str] | None = None) -> JSONObject:
+        if app_keys is not None:
+            return self._read_app_batch(
+                tool_name="app_get_associated_resources",
+                profile=profile,
+                app_keys=app_keys,
+                read_one=lambda item_app_key: self.app_get_associated_resources(profile=profile, app_key=item_app_key, app_keys=None),
+            )
+        normalized_args = {"app_key": app_key}
+        return _safe_tool_call(
+            lambda: self._facade.app_get_associated_resources(profile=profile, app_key=app_key),
+            error_code="APP_GET_ASSOCIATED_RESOURCES_FAILED",
+            normalized_args=normalized_args,
+            suggested_next_call={"tool_name": "app_get_associated_resources", "arguments": {"profile": profile, "app_key": app_key}},
+        )
+
     @tool_cn_name("门户列表查询")
     def portal_list(self, *, profile: str) -> JSONObject:
         """执行门户相关逻辑。"""
@@ -1489,7 +1892,6 @@ class AiBuilderTools(ToolBase):
         icon: str = "",
         color: str = "",
         visibility: JSONObject | None = None,
-        create_if_missing: bool = False,
         add_fields: list[JSONObject],
         update_fields: list[JSONObject],
         remove_fields: list[JSONObject],
@@ -1504,7 +1906,6 @@ class AiBuilderTools(ToolBase):
             icon=icon,
             color=color,
             visibility=visibility,
-            create_if_missing=create_if_missing,
             add_fields=add_fields,
             update_fields=update_fields,
             remove_fields=remove_fields,
@@ -1520,7 +1921,6 @@ class AiBuilderTools(ToolBase):
                     "icon": icon,
                     "color": color,
                     "visibility": visibility,
-                    "create_if_missing": create_if_missing,
                     "add_fields": add_fields,
                     "update_fields": update_fields,
                     "remove_fields": remove_fields,
@@ -1541,7 +1941,6 @@ class AiBuilderTools(ToolBase):
                         "icon": icon,
                         "color": color,
                         "visibility": visibility,
-                        "create_if_missing": create_if_missing,
                         "add_fields": [{"name": "字段名称", "type": "text"}],
                         "update_fields": [],
                         "remove_fields": [],
@@ -1604,6 +2003,52 @@ class AiBuilderTools(ToolBase):
             suggested_next_call={"tool_name": "app_layout_plan", "arguments": {"profile": profile, **normalized_request}},
         )
 
+    @tool_cn_name("应用流程规划")
+    def app_flow_plan(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        mode: str = "replace",
+        nodes: list[JSONObject] | None = None,
+        transitions: list[JSONObject] | None = None,
+        preset: str | None = None,
+    ) -> JSONObject:
+        """执行应用相关逻辑。"""
+        try:
+            request = FlowPlanRequest.model_validate(
+                {
+                    "app_key": app_key,
+                    "mode": mode,
+                    "nodes": nodes or [],
+                    "transitions": transitions or [],
+                    "preset": preset,
+                }
+            )
+        except ValidationError as exc:
+            return _validation_failure(
+                str(exc),
+                tool_name="app_flow_plan",
+                exc=exc,
+                suggested_next_call={
+                    "tool_name": "app_flow_plan",
+                    "arguments": {
+                        "profile": profile,
+                        "app_key": app_key,
+                        "mode": "replace",
+                        "preset": "basic_approval",
+                        "nodes": [],
+                        "transitions": [],
+                    },
+                },
+            )
+        return _safe_tool_call(
+            lambda: self._facade.app_flow_plan(profile=profile, request=request),
+            error_code="FLOW_PLAN_FAILED",
+            normalized_args=request.model_dump(mode="json"),
+            suggested_next_call={"tool_name": "app_flow_plan", "arguments": {"profile": profile, **request.model_dump(mode="json")}},
+        )
+
     @tool_cn_name("应用视图规划")
     def app_views_plan(
         self,
@@ -1611,6 +2056,7 @@ class AiBuilderTools(ToolBase):
         profile: str,
         app_key: str,
         upsert_views: list[JSONObject] | None = None,
+        patch_views: list[JSONObject] | None = None,
         remove_views: list[str] | None = None,
         preset: str | None = None,
     ) -> JSONObject:
@@ -1629,6 +2075,7 @@ class AiBuilderTools(ToolBase):
                 {
                     "app_key": app_key,
                     "upsert_views": upsert_views or [],
+                    "patch_views": patch_views or [],
                     "remove_views": remove_views or [],
                     "preset": preset,
                 }
@@ -1645,6 +2092,7 @@ class AiBuilderTools(ToolBase):
                         "app_key": app_key,
                         "preset": "default_table",
                         "upsert_views": [],
+                        "patch_views": [],
                         "remove_views": [],
                     },
                 },
@@ -1652,8 +2100,24 @@ class AiBuilderTools(ToolBase):
         return _safe_tool_call(
             lambda: self._facade.app_views_plan(profile=profile, request=request),
             error_code="VIEWS_PLAN_FAILED",
-            normalized_args=request.model_dump(mode="json"),
-            suggested_next_call={"tool_name": "app_views_plan", "arguments": {"profile": profile, **request.model_dump(mode="json")}},
+            normalized_args={
+                "app_key": request.app_key,
+                "upsert_views": [public_view_upsert_payload(view) for view in request.upsert_views],
+                "patch_views": [public_view_partial_payload(patch) for patch in request.patch_views],
+                "remove_views": list(request.remove_views),
+                "preset": request.preset.value if request.preset is not None else None,
+            },
+            suggested_next_call={
+                "tool_name": "app_views_plan",
+                "arguments": {
+                    "profile": profile,
+                    "app_key": request.app_key,
+                    "upsert_views": [public_view_upsert_payload(view) for view in request.upsert_views],
+                    "patch_views": [public_view_partial_payload(patch) for patch in request.patch_views],
+                    "remove_views": list(request.remove_views),
+                    "preset": request.preset.value if request.preset is not None else None,
+                },
+            },
         )
 
     @tool_cn_name("应用结构应用")
@@ -1671,8 +2135,8 @@ class AiBuilderTools(ToolBase):
         icon_color: str | None = None,
         icon_config: JSONObject | None = None,
         visibility: JSONObject | None = None,
-        create_if_missing: bool = False,
         publish: bool = True,
+        form: list[JSONObject] | None = None,
         add_fields: list[JSONObject],
         update_fields: list[JSONObject],
         remove_fields: list[JSONObject],
@@ -1698,11 +2162,25 @@ class AiBuilderTools(ToolBase):
             package_id = normalized_apps_payload.get("package_id")  # type: ignore[assignment]
             apps = normalized_apps_payload.get("apps")  # type: ignore[assignment]
             input_warnings = list(normalized_apps_payload.get("warnings") or [])
+            normalized_apps: list[JSONObject] = []
+            for index, app_item in enumerate(apps or []):
+                if not isinstance(app_item, dict):
+                    normalized_apps.append(app_item)
+                    continue
+                form_result = _apply_schema_form_to_payload(
+                    tool_name="app_schema_apply",
+                    payload=app_item,
+                    path=f"apps[{index}]",
+                )
+                failure = form_result.get("failure")
+                if isinstance(failure, dict):
+                    return _attach_builder_apply_envelope("app_schema_apply", failure)
+                normalized_apps.append(form_result.get("payload") or app_item)
+            apps = normalized_apps
             result = self._app_schema_apply_multi(
                 profile=profile,
                 package_id=package_id,
                 visibility=visibility,
-                create_if_missing=create_if_missing,
                 publish=publish,
                 apps=apps,
             )
@@ -1711,6 +2189,22 @@ class AiBuilderTools(ToolBase):
                 result_warnings.extend(deepcopy(input_warnings))
                 result["warnings"] = result_warnings
             return _attach_builder_apply_envelope("app_schema_apply", result)
+        inline_form_layout_sections: list[JSONObject] = []
+        if form:
+            form_payload: JSONObject = {"form": form}
+            if add_fields:
+                form_payload["add_fields"] = add_fields
+            form_result = _apply_schema_form_to_payload(
+                tool_name="app_schema_apply",
+                payload=form_payload,
+                path="schema",
+            )
+            failure = form_result.get("failure")
+            if isinstance(failure, dict):
+                return _attach_builder_apply_envelope("app_schema_apply", failure)
+            normalized_payload = form_result.get("payload") if isinstance(form_result.get("payload"), dict) else {}
+            add_fields = list(normalized_payload.get("add_fields") or [])
+            inline_form_layout_sections = list(form_result.get("layout_sections") or [])
         result = self._app_schema_apply_once(
             profile=profile,
             app_key=app_key,
@@ -1720,11 +2214,11 @@ class AiBuilderTools(ToolBase):
             icon=icon,
             color=color,
             visibility=visibility,
-            create_if_missing=create_if_missing,
             publish=publish,
             add_fields=add_fields,
             update_fields=update_fields,
             remove_fields=remove_fields,
+            inline_form_layout_sections=inline_form_layout_sections,
         )
         result = self._retry_after_self_lock_release(
             profile=profile,
@@ -1738,11 +2232,11 @@ class AiBuilderTools(ToolBase):
                 icon=icon,
                 color=color,
                 visibility=visibility,
-                create_if_missing=create_if_missing,
                 publish=publish,
                 add_fields=add_fields,
                 update_fields=update_fields,
                 remove_fields=remove_fields,
+                inline_form_layout_sections=inline_form_layout_sections,
             ),
         )
         return _attach_builder_apply_envelope("app_schema_apply", result)
@@ -1753,52 +2247,116 @@ class AiBuilderTools(ToolBase):
         profile: str,
         package_id: int | None,
         visibility: JSONObject | None,
-        create_if_missing: bool,
         publish: bool,
         apps: list[JSONObject],
     ) -> JSONObject:
+        started_at = time.perf_counter()
+        validation_ms = 0
+        app_shell_apply_ms = 0
+        relation_compile_ms = 0
+        app_field_apply_ms = 0
+        relation_repair_ms = 0
+        inline_layout_fallback_ms = 0
+        child_schema_write_ms = 0
+        child_inline_layout_ms = 0
+        child_publish_ms = 0
+        child_readback_ms = 0
         normalized_args: JSONObject = {
             "package_id": package_id,
-            "create_if_missing": create_if_missing,
             "publish": publish,
             "apps": deepcopy(apps),
         }
         if visibility is not None:
             normalized_args["visibility"] = deepcopy(visibility)
+        parallelism: JSONObject = {"shell_workers": 0, "schema_workers": 0}
+
+        def merge_child_duration(child: JSONObject) -> None:
+            nonlocal child_schema_write_ms
+            nonlocal child_inline_layout_ms
+            nonlocal child_publish_ms
+            nonlocal child_readback_ms
+            breakdown = child.get("duration_breakdown_ms") if isinstance(child, dict) else None
+            if not isinstance(breakdown, dict):
+                return
+            for key, target in (
+                ("schema_write_ms", "child_schema_write_ms"),
+                ("inline_layout_ms", "child_inline_layout_ms"),
+                ("publish_ms", "child_publish_ms"),
+                ("readback_ms", "child_readback_ms"),
+            ):
+                value = breakdown.get(key)
+                if isinstance(value, (int, float)) and value >= 0:
+                    if target == "child_schema_write_ms":
+                        child_schema_write_ms += int(value)
+                    elif target == "child_inline_layout_ms":
+                        child_inline_layout_ms += int(value)
+                    elif target == "child_publish_ms":
+                        child_publish_ms += int(value)
+                    elif target == "child_readback_ms":
+                        child_readback_ms += int(value)
+
+        def finish(response: JSONObject) -> JSONObject:
+            _merge_duration_breakdown(
+                response,
+                multi_app_validation_ms=validation_ms,
+                app_shell_apply_ms=app_shell_apply_ms,
+                app_shell_parallel_wall_ms=app_shell_apply_ms,
+                relation_compile_ms=relation_compile_ms,
+                app_field_apply_ms=app_field_apply_ms,
+                app_schema_parallel_wall_ms=app_field_apply_ms,
+                relation_repair_parallel_wall_ms=relation_repair_ms,
+                native_inline_layout_ms=child_inline_layout_ms,
+                inline_layout_fallback_ms=inline_layout_fallback_ms,
+                child_schema_write_ms=child_schema_write_ms,
+                child_inline_layout_ms=child_inline_layout_ms,
+                child_publish_ms=child_publish_ms,
+                child_readback_ms=child_readback_ms,
+                total_ms=_elapsed_ms(started_at),
+            )
+            return response
+
+        validation_started_at = time.perf_counter()
         system_field_failure = _reserved_system_field_name_failure_for_apps(
             tool_name="app_schema_apply",
             profile=profile,
             package_id=package_id,
             visibility=visibility,
-            create_if_missing=create_if_missing,
             publish=publish,
             apps=apps,
         )
         if system_field_failure is not None:
-            return system_field_failure
+            validation_ms += _elapsed_ms(validation_started_at)
+            return finish(system_field_failure)
         if package_id is None:
-            return _config_failure(
-                tool_name="app_schema_apply",
-                message="app_schema_apply multi-app mode requires package_id.",
-                fix_hint="Pass package_id and apps[].app_name for new apps, or apps[].app_key for existing apps.",
+            validation_ms += _elapsed_ms(validation_started_at)
+            return finish(
+                _config_failure(
+                    tool_name="app_schema_apply",
+                    message="app_schema_apply multi-app mode requires package_id.",
+                    fix_hint="Pass package_id and apps[].app_name for new apps, or apps[].app_key for existing apps.",
+                )
             )
         if not apps:
-            return _config_failure(
-                tool_name="app_schema_apply",
-                error_code="APPS_FILE_EMPTY",
-                message="app_schema_apply multi-app mode requires non-empty apps.",
-                fix_hint="Pass apps as a non-empty list of app schema items.",
+            validation_ms += _elapsed_ms(validation_started_at)
+            return finish(
+                _config_failure(
+                    tool_name="app_schema_apply",
+                    error_code="APPS_FILE_EMPTY",
+                    message="app_schema_apply multi-app mode requires non-empty apps.",
+                    fix_hint="Pass apps as a non-empty list of app schema items.",
+                )
             )
         shape_failure = _schema_apps_shape_failure(tool_name="app_schema_apply", apps=apps)
         if shape_failure is not None:
-            return shape_failure
+            validation_ms += _elapsed_ms(validation_started_at)
+            return finish(shape_failure)
         static_validation_failure = _multi_app_static_validation_failure(
             tool_name="app_schema_apply",
             apps=apps,
-            create_if_missing=create_if_missing,
         )
         if static_validation_failure is not None:
-            return static_validation_failure
+            validation_ms += _elapsed_ms(validation_started_at)
+            return finish(static_validation_failure)
         icon_errors: list[JSONObject] = []
         seen_new_app_icons: dict[str, int] = {}
         for index, raw_item in enumerate(apps):
@@ -1849,32 +2407,111 @@ class AiBuilderTools(ToolBase):
                 else:
                     seen_new_app_icons[normalized_icon] = index
         if icon_errors:
-            return _config_failure(
-                tool_name="app_schema_apply",
-                error_code="WORKSPACE_ICON_BATCH_INVALID",
-                message="one or more apps have invalid workspace icon configuration",
-                fix_hint="Call `qingflow --json builder icon catalog`, choose a distinct non-template icon and color for each new app, then retry.",
-                details={"icon_errors": icon_errors},
-                allowed_values={
-                    "workspace_icon.icon_names": list(WORKSPACE_ICON_NAMES),
-                    "workspace_icon.icon_colors": list(WORKSPACE_ICON_COLORS),
-                    "workspace_icon.generic_icon_names": list(GENERIC_WORKSPACE_ICON_NAMES),
-                },
+            validation_ms += _elapsed_ms(validation_started_at)
+            return finish(
+                _config_failure(
+                    tool_name="app_schema_apply",
+                    error_code="WORKSPACE_ICON_BATCH_INVALID",
+                    message="one or more apps have invalid workspace icon configuration",
+                    fix_hint="Call `qingflow --json builder icon catalog`, choose a distinct non-template icon and color for each new app, then retry.",
+                    details={"icon_errors": icon_errors},
+                    allowed_values={
+                        "workspace_icon.icon_names": list(WORKSPACE_ICON_NAMES),
+                        "workspace_icon.icon_colors": list(WORKSPACE_ICON_COLORS),
+                        "workspace_icon.generic_icon_names": list(GENERIC_WORKSPACE_ICON_NAMES),
+                    },
+                )
             )
+        validation_ms += _elapsed_ms(validation_started_at)
 
         client_key_to_app_key: dict[str, str] = {}
         app_name_to_app_key: dict[str, str] = {}
         created_app_keys: list[str] = []
-        results: list[JSONObject] = []
+        results_by_index: list[JSONObject | None] = [None] * len(apps)
+        shell_jobs: list[JSONObject] = []
         any_write_executed = False
         any_write_may_have_succeeded = False
         pending_readback_app_keys: list[str] = []
         pending_readback_app_names: list[str] = []
         client_keys: set[str] = set()
+        client_key_indexes: dict[str, int] = {}
+        app_name_indexes: dict[str, int] = {}
+
+        def worker_count(count: int) -> int:
+            return min(MULTI_APP_SCHEMA_APPLY_PARALLEL_LIMIT, count) if count > 0 else 0
+
+        def mark_inline_layout_not_applied_in_schema(
+            result: JSONObject,
+            *,
+            app_key: str,
+            sections: list[JSONObject],
+        ) -> JSONObject:
+            marked = deepcopy(result)
+            inline_payload: JSONObject = {
+                "requested": True,
+                "section_count": len(sections),
+                "app_key": app_key or None,
+                "applied": False,
+                "applied_in_schema": False,
+                "error_code": "INLINE_FORM_LAYOUT_NOT_APPLIED_IN_SCHEMA",
+                "message": "schema save did not apply inline form layout; multi-app mode does not run app_layout_apply fallback",
+            }
+            marked["inline_form_layout"] = inline_payload
+            verification = marked.get("verification") if isinstance(marked.get("verification"), dict) else {}
+            verification = deepcopy(verification)
+            verification["inline_form_layout_verified"] = False
+            marked["verification"] = verification
+            if marked.get("status") in {"success", "partial_success"}:
+                marked["status"] = "partial_success"
+                marked["error_code"] = marked.get("error_code") or "INLINE_FORM_LAYOUT_NOT_APPLIED_IN_SCHEMA"
+                marked["message"] = "schema applied but inline form layout was not applied in schema save"
+            marked["safe_to_retry"] = False
+            return marked
+
+        def dependency_failure_for_item(index: int, item: JSONObject) -> JSONObject | None:
+            blocked: list[JSONObject] = []
+            for ref in _collect_multi_app_target_refs(item, path=f"apps[{index}]"):
+                ref_value = str(ref.get("value") or "").strip()
+                if not ref_value:
+                    continue
+                target_index: int | None = None
+                resolved = False
+                if ref.get("kind") == "target_app_ref":
+                    target_index = client_key_indexes.get(ref_value)
+                    resolved = ref_value in client_key_to_app_key
+                elif ref.get("kind") == "target_app":
+                    target_index = app_name_indexes.get(ref_value)
+                    resolved = ref_value in app_name_to_app_key
+                if target_index is None or resolved:
+                    continue
+                target_result = results_by_index[target_index] if 0 <= target_index < len(results_by_index) else None
+                blocked.append(
+                    {
+                        "kind": ref.get("kind"),
+                        "value": ref_value,
+                        "path": ref.get("path"),
+                        "target_index": target_index,
+                        "target_status": target_result.get("status") if isinstance(target_result, dict) else None,
+                        "target_error_code": target_result.get("error_code") if isinstance(target_result, dict) else None,
+                    }
+                )
+            if not blocked:
+                return None
+            raw_item = apps[index] if 0 <= index < len(apps) else item
+            failure = _multi_app_item_failure(
+                index,
+                raw_item,
+                "DEPENDENCY_APP_NOT_READY",
+                "one or more target apps failed or require readback, so this app schema was not written",
+            )
+            failure["stage"] = "dependency_check"
+            failure["safe_to_retry"] = False
+            failure["details"] = {"blocked_dependencies": blocked}
+            return failure
 
         for index, raw_item in enumerate(apps):
             if not isinstance(raw_item, dict):
-                results.append(_multi_app_item_failure(index, raw_item, "INVALID_APP_ITEM", "apps[] items must be objects"))
+                results_by_index[index] = _multi_app_item_failure(index, raw_item, "INVALID_APP_ITEM", "apps[] items must be objects")
                 continue
             item = deepcopy(raw_item)
             client_key = str(item.get("client_key") or item.get("clientKey") or "").strip()
@@ -1882,51 +2519,124 @@ class AiBuilderTools(ToolBase):
             app_key = str(item.get("app_key") or item.get("appKey") or "").strip()
             if client_key:
                 if client_key in client_keys:
-                    results.append(_multi_app_item_failure(index, item, "DUPLICATE_CLIENT_KEY", f"duplicate client_key '{client_key}'"))
+                    results_by_index[index] = _multi_app_item_failure(index, item, "DUPLICATE_CLIENT_KEY", f"duplicate client_key '{client_key}'")
                     continue
                 client_keys.add(client_key)
+                client_key_indexes[client_key] = index
+            if app_name:
+                app_name_indexes[app_name] = index
             if not app_key and not app_name:
-                results.append(_multi_app_item_failure(index, item, "APP_SELECTOR_REQUIRED", "apps[] requires app_key or app_name"))
+                results_by_index[index] = _multi_app_item_failure(index, item, "APP_SELECTOR_REQUIRED", "apps[] requires app_key or app_name")
                 continue
-
-            initial_add_fields, deferred_add_fields = _split_multi_app_initial_add_fields(item, is_new_app=not bool(app_key))
-            item["_deferred_add_fields"] = deferred_add_fields
-            shell = self._app_schema_apply_once(
-                profile=profile,
-                app_key=app_key,
-                package_id=package_id if not app_key else None,
-                app_name=app_name,
-                app_title="",
-                icon=str(item.get("icon") or ""),
-                color=str(item.get("color") or ""),
-                visibility=item.get("visibility", visibility),
-                create_if_missing=create_if_missing and not app_key,
-                publish=publish and not deferred_add_fields,
-                add_fields=initial_add_fields,
-                update_fields=[],
-                remove_fields=[],
+            shell_jobs.append(
+                {
+                    "index": index,
+                    "item": item,
+                    "client_key": client_key,
+                    "app_name": app_name,
+                    "app_key": app_key,
+                }
             )
-            public_shell = _publicize_package_fields(shell)
-            resolved_key = str(public_shell.get("app_key") or "").strip()
-            shell_write_executed = _schema_apply_result_has_write(public_shell)
-            shell_write_may_have_succeeded = _schema_apply_result_may_have_write(public_shell)
-            if shell_write_executed:
-                any_write_executed = True
-            if shell_write_may_have_succeeded:
-                any_write_may_have_succeeded = True
-            if public_shell.get("status") not in {"success", "partial_success"} or not resolved_key:
-                pending_readback = bool(shell_write_may_have_succeeded or shell_write_executed) and (
-                    str(public_shell.get("next_action") or "") == "readback_before_retry"
-                    or bool((public_shell.get("verification") if isinstance(public_shell.get("verification"), dict) else {}).get("readback_before_retry"))
-                    or not resolved_key
+
+        shell_workers = worker_count(len(shell_jobs))
+        parallelism["shell_workers"] = shell_workers
+
+        def run_shell_job(job: JSONObject) -> JSONObject:
+            index = int(job["index"])
+            item = deepcopy(job["item"])
+            app_key = str(job.get("app_key") or "")
+            app_name = str(job.get("app_name") or "")
+            shell_started_at = time.perf_counter()
+            try:
+                shell = self._app_schema_apply_once(
+                    profile=profile,
+                    app_key=app_key,
+                    package_id=package_id if not app_key else None,
+                    app_name=app_name,
+                    app_title="",
+                    icon=str(item.get("icon") or ""),
+                    color=str(item.get("color") or ""),
+                    visibility=item.get("visibility", visibility),
+                    publish=False,
+                    add_fields=[],
+                    update_fields=[],
+                    remove_fields=[],
+                    inline_form_layout_sections=None,
+                    allow_inline_layout_fallback=False,
                 )
-                item_status = "pending_readback" if pending_readback else "failed"
-                if pending_readback:
+                return {
+                    "index": index,
+                    "job": job,
+                    "elapsed_ms": _elapsed_ms(shell_started_at),
+                    "public_shell": _publicize_package_fields(shell),
+                }
+            except Exception as error:  # pragma: no cover - defensive guard for unexpected worker failures
+                return {
+                    "index": index,
+                    "job": job,
+                    "elapsed_ms": _elapsed_ms(shell_started_at),
+                    "exception": repr(error),
+                }
+
+        shell_outputs: list[JSONObject] = []
+        shell_phase_started_at = time.perf_counter()
+        if shell_jobs:
+            with ThreadPoolExecutor(max_workers=shell_workers) as executor:
+                futures = [executor.submit(run_shell_job, job) for job in shell_jobs]
+                for future in as_completed(futures):
+                    shell_outputs.append(future.result())
+        app_shell_apply_ms += _elapsed_ms(shell_phase_started_at)
+
+        for output in sorted(shell_outputs, key=lambda item: int(item.get("index", 0))):
+            index = int(output["index"])
+            job = output.get("job") if isinstance(output.get("job"), dict) else {}
+            client_key = str(job.get("client_key") or "").strip()
+            app_name = str(job.get("app_name") or "").strip()
+            app_key = str(job.get("app_key") or "").strip()
+            item = deepcopy(job.get("item") if isinstance(job.get("item"), dict) else {})
+            exception = output.get("exception")
+            if exception:
+                results_by_index[index] = {
+                    "index": index,
+                    "row_number": index + 1,
+                    "client_key": client_key or None,
+                    "app_name": app_name or None,
+                    "app_key": app_key or None,
+                    "status": "pending_readback",
+                    "stage": "resolve_or_create_shell",
+                    "error_code": "APP_SHELL_APPLY_EXCEPTION",
+                    "message": str(exception),
+                    "write_executed": False,
+                    "write_may_have_succeeded": True,
+                    "safe_to_retry": False,
+                    "next_action": "readback_before_retry",
+                }
+                if app_name:
+                    pending_readback_app_names.append(app_name)
+                any_write_may_have_succeeded = True
+                continue
+            public_shell = output.get("public_shell") if isinstance(output.get("public_shell"), dict) else {}
+            merge_child_duration(public_shell)
+            resolved_key = str(public_shell.get("app_key") or "").strip()
+            shell_write_executed = _schema_apply_result_has_write(public_shell)
+            shell_write_may_have_succeeded = _schema_apply_result_may_have_write(public_shell)
+            if shell_write_executed:
+                any_write_executed = True
+            if shell_write_may_have_succeeded:
+                any_write_may_have_succeeded = True
+            if public_shell.get("status") not in {"success", "partial_success"} or not resolved_key:
+                pending_readback = bool(shell_write_may_have_succeeded or shell_write_executed) and (
+                    str(public_shell.get("next_action") or "") == "readback_before_retry"
+                    or bool((public_shell.get("verification") if isinstance(public_shell.get("verification"), dict) else {}).get("readback_before_retry"))
+                    or not resolved_key
+                )
+                item_status = "pending_readback" if pending_readback else "failed"
+                if pending_readback:
                     if resolved_key:
                         pending_readback_app_keys.append(resolved_key)
                     if app_name:
                         pending_readback_app_names.append(app_name)
-                results.append({
+                results_by_index[index] = {
                     "index": index,
                     "row_number": index + 1,
                     "client_key": client_key or None,
@@ -1941,8 +2651,8 @@ class AiBuilderTools(ToolBase):
                     "safe_to_retry": False if pending_readback else (not shell_write_executed and not any_write_executed),
                     **({"next_action": "readback_before_retry"} if pending_readback else {}),
                     **({"verification": public_shell.get("verification")} if isinstance(public_shell.get("verification"), dict) else {}),
-                    **({"created": True} if pending_readback and create_if_missing and not app_key else {}),
-                })
+                    **({"created": True} if pending_readback and not app_key else {}),
+                }
                 continue
             if bool(public_shell.get("created")):
                 created_app_keys.append(resolved_key)
@@ -1955,7 +2665,7 @@ class AiBuilderTools(ToolBase):
             resolved_name = str(public_shell.get("app_name_after") or public_shell.get("app_name") or app_name or "").strip()
             if resolved_name:
                 app_name_to_app_key[resolved_name] = resolved_key
-            results.append({
+            results_by_index[index] = {
                 "index": index,
                 "row_number": index + 1,
                 "client_key": client_key or None,
@@ -1966,80 +2676,246 @@ class AiBuilderTools(ToolBase):
                 "shell_result": public_shell,
                 "shell_field_diff": public_shell.get("field_diff") or {},
                 "shell_field_diff_details": public_shell.get("field_diff_details") or {},
-                "deferred_add_fields": deferred_add_fields,
-            })
+            }
 
-        final_items: list[JSONObject] = []
+        final_items_by_index: list[JSONObject | None] = [None] * len(apps)
+        schema_jobs: list[JSONObject] = []
         for index, raw_item in enumerate(apps):
-            existing = next((item for item in results if item.get("index") == index), None)
+            existing = results_by_index[index] if 0 <= index < len(results_by_index) else None
             if not existing or existing.get("status") != "shell_ready":
                 if existing:
-                    final_items.append(existing)
+                    final_items_by_index[index] = existing
                 continue
             item = deepcopy(raw_item)
             app_key = str(existing.get("app_key") or "").strip()
+            dependency_failure = dependency_failure_for_item(index, item)
+            if dependency_failure is not None:
+                final_items_by_index[index] = dependency_failure
+                any_write_executed = True
+                continue
+            compile_started_at = time.perf_counter()
             try:
                 compiled_item = _compile_multi_app_schema_item_refs(item, client_key_to_app_key, app_name_to_app_key)
             except ValueError as error:
-                final_items.append({
+                relation_compile_ms += _elapsed_ms(compile_started_at)
+                final_items_by_index[index] = {
                     **{key: existing.get(key) for key in ("index", "row_number", "client_key", "app_name", "app_key", "created")},
                     "status": "failed",
                     "stage": "compile_relation_refs",
                     "error_code": "TARGET_APP_REF_NOT_FOUND",
                     "message": str(error),
                     "safe_to_retry": False,
-                })
+                }
                 any_write_executed = True
                 continue
-
-            deferred_add_fields = (
-                _compiled_multi_app_deferred_add_fields(compiled_item, existing)
-                if bool(existing.get("created"))
-                else list(compiled_item.get("add_fields") or [])
-            )
+            relation_compile_ms += _elapsed_ms(compile_started_at)
+            schema_add_fields = list(compiled_item.get("add_fields") or [])
             update_fields = list(compiled_item.get("update_fields") or [])
             remove_fields = list(compiled_item.get("remove_fields") or [])
-            if bool(existing.get("created")) and not deferred_add_fields and not update_fields and not remove_fields:
-                shell_result = existing.get("shell_result") if isinstance(existing.get("shell_result"), dict) else {}
-                item_status = shell_result.get("status") if shell_result.get("status") in {"success", "partial_success"} else "failed"
-                shell_field_diff = existing.get("shell_field_diff") if isinstance(existing.get("shell_field_diff"), dict) else {}
-                shell_field_diff_details = existing.get("shell_field_diff_details") if isinstance(existing.get("shell_field_diff_details"), dict) else {}
-                final_items.append({
+            layout_sections = list(compiled_item.get("_inline_form_layout_sections") or [])
+            field_phase_app_name = ""
+            field_phase_icon = ""
+            field_phase_color = ""
+            field_phase_visibility = None
+            relation_fields_for_retry = [
+                deepcopy(field)
+                for field in schema_add_fields
+                if isinstance(field, dict) and _multi_app_field_type(field) == PublicFieldType.relation.value
+            ]
+            schema_jobs.append(
+                {
+                    "index": index,
+                    "existing": existing,
+                    "item": item,
+                    "app_key": app_key,
+                    "field_phase_app_name": field_phase_app_name,
+                    "field_phase_icon": field_phase_icon,
+                    "field_phase_color": field_phase_color,
+                    "field_phase_visibility": field_phase_visibility,
+                    "schema_add_fields": schema_add_fields,
+                    "update_fields": update_fields,
+                    "remove_fields": remove_fields,
+                    "layout_sections": layout_sections,
+                    "relation_fields_for_retry": relation_fields_for_retry,
+                }
+            )
+
+        schema_workers = worker_count(len(schema_jobs))
+        parallelism["schema_workers"] = schema_workers
+        parallelism["schema_wave_count"] = 0
+        parallelism["schema_wave_sizes"] = []
+
+        def run_schema_job(job: JSONObject) -> JSONObject:
+            index = int(job["index"])
+            app_key = str(job.get("app_key") or "")
+            field_phase_app_name = str(job.get("field_phase_app_name") or "")
+            field_phase_icon = str(job.get("field_phase_icon") or "")
+            field_phase_color = str(job.get("field_phase_color") or "")
+            field_phase_visibility = job.get("field_phase_visibility")
+            schema_add_fields = list(job.get("schema_add_fields") or [])
+            update_fields = list(job.get("update_fields") or [])
+            remove_fields = list(job.get("remove_fields") or [])
+            layout_sections = list(job.get("layout_sections") or [])
+            relation_fields_for_retry = list(job.get("relation_fields_for_retry") or [])
+            field_started_at = time.perf_counter()
+            try:
+                field_result = self._app_schema_apply_once(
+                    profile=profile,
+                    app_key=app_key,
+                    package_id=None,
+                    app_name=field_phase_app_name,
+                    app_title="",
+                    icon=field_phase_icon,
+                    color=field_phase_color,
+                    visibility=field_phase_visibility,
+                    publish=publish,
+                    add_fields=schema_add_fields,
+                    update_fields=update_fields,
+                    remove_fields=remove_fields,
+                    inline_form_layout_sections=layout_sections,
+                    allow_inline_layout_fallback=False,
+                )
+                public_result = _publicize_package_fields(field_result)
+            except Exception as error:  # pragma: no cover - defensive guard for unexpected worker failures
+                return {
+                    "index": index,
+                    "job": job,
+                    "elapsed_ms": _elapsed_ms(field_started_at),
+                    "exception": repr(error),
+                }
+            if _multi_app_deferred_relation_retryable(public_result, relation_fields_for_retry):
+                first_error = {
+                    "error_code": public_result.get("error_code"),
+                    "message": public_result.get("message"),
+                    "backend_code": public_result.get("backend_code"),
+                    "http_status": public_result.get("http_status"),
+                    "details": deepcopy(public_result.get("details")) if isinstance(public_result.get("details"), dict) else None,
+                }
+                retry_attempts: list[JSONObject] = []
+                for retry_index, delay_seconds in enumerate((1.0, 5.0), start=1):
+                    retry_readback = self._stabilize_deferred_relation_metadata(
+                        profile=profile,
+                        source_app_key=app_key,
+                        deferred_add_fields=relation_fields_for_retry,
+                        delay_seconds=delay_seconds,
+                    )
+                    retry_result = self._app_schema_apply_once(
+                        profile=profile,
+                        app_key=app_key,
+                        package_id=None,
+                        app_name=field_phase_app_name,
+                        app_title="",
+                        icon=field_phase_icon,
+                        color=field_phase_color,
+                        visibility=field_phase_visibility,
+                        publish=publish,
+                        add_fields=schema_add_fields,
+                        update_fields=update_fields,
+                        remove_fields=remove_fields,
+                        inline_form_layout_sections=layout_sections,
+                        allow_inline_layout_fallback=False,
+                    )
+                    public_retry_result = _publicize_package_fields(retry_result)
+                    retry_attempts.append(
+                        {
+                            "attempt": retry_index,
+                            "delay_seconds": delay_seconds,
+                            "status": public_retry_result.get("status"),
+                            "error_code": public_retry_result.get("error_code"),
+                            "backend_code": public_retry_result.get("backend_code"),
+                            "http_status": public_retry_result.get("http_status"),
+                            "readback": retry_readback,
+                        }
+                    )
+                    public_result = public_retry_result
+                    if not _multi_app_deferred_relation_retryable(public_result, relation_fields_for_retry):
+                        break
+                retry_details = public_result.get("details")
+                if not isinstance(retry_details, dict):
+                    retry_details = {}
+                    public_result["details"] = retry_details
+                retry_summary: JSONObject = {
+                    "attempted": True,
+                    "reason": "same_batch_relation_metadata_may_lag",
+                    "first_error": first_error,
+                    "attempts": retry_attempts,
+                }
+                if retry_attempts:
+                    retry_summary["readback"] = retry_attempts[-1].get("readback")
+                retry_details["deferred_relation_retry"] = retry_summary
+            if layout_sections and not _inline_form_layout_was_handled(public_result):
+                public_result = mark_inline_layout_not_applied_in_schema(
+                    public_result,
+                    app_key=app_key,
+                    sections=layout_sections,
+                )
+            return {
+                "index": index,
+                "job": job,
+                "elapsed_ms": _elapsed_ms(field_started_at),
+                "public_result": public_result,
+            }
+
+        def schema_job_dependency_indexes(job: JSONObject) -> set[int]:
+            index = int(job.get("index", -1))
+            item = job.get("item") if isinstance(job.get("item"), dict) else {}
+            dependencies: set[int] = set()
+            for ref in _collect_multi_app_target_refs(item, path=f"apps[{index}]"):
+                ref_value = str(ref.get("value") or "").strip()
+                if not ref_value:
+                    continue
+                target_index: int | None = None
+                if ref.get("kind") == "target_app_ref":
+                    target_index = client_key_indexes.get(ref_value)
+                elif ref.get("kind") == "target_app":
+                    target_index = app_name_indexes.get(ref_value)
+                if target_index is None or target_index == index:
+                    continue
+                dependencies.add(target_index)
+            return dependencies
+
+        def schema_dependency_failure(index: int, job: JSONObject, blocked_dependencies: list[JSONObject]) -> JSONObject:
+            existing = job.get("existing") if isinstance(job.get("existing"), dict) else {}
+            return {
+                **{key: existing.get(key) for key in ("index", "row_number", "client_key", "app_name", "app_key", "created")},
+                "status": "failed",
+                "stage": "schema_dependency_check",
+                "error_code": "DEPENDENCY_SCHEMA_NOT_READY",
+                "message": "one or more same-batch target app schemas failed or are not ready, so this app schema was not written",
+                "write_executed": False,
+                "write_may_have_succeeded": False,
+                "safe_to_retry": False,
+                "details": {"blocked_dependencies": blocked_dependencies},
+            }
+
+        def process_schema_output(output: JSONObject) -> None:
+            nonlocal any_write_executed
+            nonlocal any_write_may_have_succeeded
+            index = int(output["index"])
+            job = output.get("job") if isinstance(output.get("job"), dict) else {}
+            existing = job.get("existing") if isinstance(job.get("existing"), dict) else {}
+            app_key = str(job.get("app_key") or "")
+            exception = output.get("exception")
+            if exception:
+                final_items_by_index[index] = {
                     **{key: existing.get(key) for key in ("index", "row_number", "client_key", "app_name", "app_key", "created")},
-                    "status": item_status,
+                    "status": "pending_readback",
                     "stage": "schema_apply",
-                    "field_diff": shell_field_diff,
-                    "field_diff_details": shell_field_diff_details,
-                    "shell_field_diff": shell_field_diff,
-                    "shell_field_diff_details": shell_field_diff_details,
-                    "published": bool(shell_result.get("published")),
-                    "verified": bool(shell_result.get("verified")),
-                    "error_code": shell_result.get("error_code"),
-                    "message": shell_result.get("message"),
-                    "write_executed": _schema_apply_result_has_write(shell_result),
-                    "write_may_have_succeeded": _schema_apply_result_may_have_write(shell_result),
+                    "error_code": "SCHEMA_APPLY_EXCEPTION",
+                    "message": str(exception),
+                    "write_executed": False,
+                    "write_may_have_succeeded": True,
                     "safe_to_retry": False,
-                    **({"next_action": shell_result.get("next_action")} if shell_result.get("next_action") else {}),
-                    **({"verification": shell_result.get("verification")} if isinstance(shell_result.get("verification"), dict) else {}),
-                })
-                continue
-
-            field_result = self._app_schema_apply_once(
-                profile=profile,
-                app_key=app_key,
-                package_id=None,
-                app_name=str(compiled_item.get("app_name") or compiled_item.get("appTitle") or compiled_item.get("app_title") or ""),
-                app_title="",
-                icon=str(compiled_item.get("icon") or ""),
-                color=str(compiled_item.get("color") or ""),
-                visibility=compiled_item.get("visibility"),
-                create_if_missing=False,
-                publish=publish,
-                add_fields=deferred_add_fields,
-                update_fields=update_fields,
-                remove_fields=remove_fields,
-            )
-            public_result = _publicize_package_fields(field_result)
+                    "next_action": "readback_before_retry",
+                }
+                if app_key:
+                    pending_readback_app_keys.append(app_key)
+                if existing.get("app_name"):
+                    pending_readback_app_names.append(str(existing.get("app_name")))
+                any_write_may_have_succeeded = True
+                return
+            public_result = output.get("public_result") if isinstance(output.get("public_result"), dict) else {}
+            merge_child_duration(public_result)
             if _schema_apply_result_has_write(public_result):
                 any_write_executed = True
             if _schema_apply_result_may_have_write(public_result):
@@ -2054,7 +2930,7 @@ class AiBuilderTools(ToolBase):
                     pending_readback_app_keys.append(app_key)
                 if existing.get("app_name"):
                     pending_readback_app_names.append(str(existing.get("app_name")))
-            final_items.append({
+            final_items_by_index[index] = {
                 **{key: existing.get(key) for key in ("index", "row_number", "client_key", "app_name", "app_key", "created")},
                 "status": item_status,
                 "stage": "schema_apply",
@@ -2069,9 +2945,225 @@ class AiBuilderTools(ToolBase):
                 "write_executed": _schema_apply_result_has_write(public_result),
                 "write_may_have_succeeded": _schema_apply_result_may_have_write(public_result),
                 "safe_to_retry": False,
+                **_multi_app_child_diagnostics(public_result),
                 **({"next_action": public_result.get("next_action")} if public_result.get("next_action") else {}),
                 **({"verification": public_result.get("verification")} if isinstance(public_result.get("verification"), dict) else {}),
-            })
+                **({"inline_form_layout": public_result.get("inline_form_layout")} if isinstance(public_result.get("inline_form_layout"), dict) else {}),
+                **({"inline_form_layout_result": public_result.get("inline_form_layout_result")} if isinstance(public_result.get("inline_form_layout_result"), dict) else {}),
+            }
+
+        schema_jobs_by_index = {int(job["index"]): job for job in schema_jobs}
+        schema_dependencies_by_index = {
+            index: schema_job_dependency_indexes(job)
+            for index, job in schema_jobs_by_index.items()
+        }
+        pending_schema_indexes = set(schema_jobs_by_index)
+        schema_phase_started_at = time.perf_counter()
+        while pending_schema_indexes:
+            blocked_this_round = False
+            for index in sorted(list(pending_schema_indexes)):
+                blocked_dependencies: list[JSONObject] = []
+                for dependency_index in sorted(schema_dependencies_by_index.get(index, set())):
+                    if dependency_index not in schema_jobs_by_index:
+                        continue
+                    dependency_result = final_items_by_index[dependency_index]
+                    if dependency_result is None:
+                        continue
+                    dependency_status = dependency_result.get("status")
+                    if dependency_status not in {"success", "partial_success"}:
+                        blocked_dependencies.append(
+                            {
+                                "target_index": dependency_index,
+                                "target_status": dependency_status,
+                                "target_error_code": dependency_result.get("error_code"),
+                                "target_app_key": dependency_result.get("app_key"),
+                                "target_app_name": dependency_result.get("app_name"),
+                            }
+                        )
+                if not blocked_dependencies:
+                    continue
+                final_items_by_index[index] = schema_dependency_failure(
+                    index,
+                    schema_jobs_by_index[index],
+                    blocked_dependencies,
+                )
+                pending_schema_indexes.remove(index)
+                blocked_this_round = True
+                any_write_executed = True
+            if blocked_this_round:
+                continue
+
+            ready_indexes = [
+                index
+                for index in sorted(pending_schema_indexes)
+                if all(
+                    dependency_index not in pending_schema_indexes
+                    for dependency_index in schema_dependencies_by_index.get(index, set())
+                    if dependency_index in schema_jobs_by_index
+                )
+            ]
+            if not ready_indexes:
+                for index in sorted(pending_schema_indexes):
+                    existing = schema_jobs_by_index[index].get("existing")
+                    existing = existing if isinstance(existing, dict) else {}
+                    final_items_by_index[index] = {
+                        **{key: existing.get(key) for key in ("index", "row_number", "client_key", "app_name", "app_key", "created")},
+                        "status": "failed",
+                        "stage": "schema_dependency_check",
+                        "error_code": "DEPENDENCY_SCHEMA_CYCLE",
+                        "message": "same-batch target_app_ref dependencies contain a cycle; schema was not written",
+                        "write_executed": False,
+                        "write_may_have_succeeded": False,
+                        "safe_to_retry": False,
+                        "details": {
+                            "dependency_indexes": sorted(schema_dependencies_by_index.get(index, set())),
+                        },
+                    }
+                    any_write_executed = True
+                pending_schema_indexes.clear()
+                break
+
+            parallelism["schema_wave_count"] = int(parallelism.get("schema_wave_count") or 0) + 1
+            schema_wave_sizes = parallelism.get("schema_wave_sizes")
+            if isinstance(schema_wave_sizes, list):
+                schema_wave_sizes.append(len(ready_indexes))
+            wave_outputs: list[JSONObject] = []
+            wave_workers = worker_count(len(ready_indexes))
+            with ThreadPoolExecutor(max_workers=wave_workers) as executor:
+                futures = [executor.submit(run_schema_job, schema_jobs_by_index[index]) for index in ready_indexes]
+                for future in as_completed(futures):
+                    wave_outputs.append(future.result())
+            for output in sorted(wave_outputs, key=lambda item: int(item.get("index", 0))):
+                process_schema_output(output)
+            for index in ready_indexes:
+                pending_schema_indexes.remove(index)
+        app_field_apply_ms += _elapsed_ms(schema_phase_started_at)
+
+        final_items: list[JSONObject] = [
+            item if isinstance(item, dict) else _multi_app_item_failure(index, apps[index], "APP_ITEM_NOT_PROCESSED", "app item was not processed")
+            for index, item in enumerate(final_items_by_index)
+        ]
+
+        def relation_repair_patches(item: JSONObject) -> list[JSONObject]:
+            details = item.get("details") if isinstance(item.get("details"), dict) else {}
+            repair_plan = details.get("relation_repair_plan") if isinstance(details.get("relation_repair_plan"), list) else []
+            patches: list[JSONObject] = []
+            for plan_item in repair_plan:
+                if not isinstance(plan_item, dict):
+                    continue
+                patch = plan_item.get("suggested_patch")
+                if isinstance(patch, dict):
+                    patches.append(deepcopy(patch))
+            return patches
+
+        relation_repair_jobs: list[JSONObject] = []
+        for item in final_items:
+            if item.get("status") != "partial_success":
+                continue
+            app_key = str(item.get("app_key") or "").strip()
+            patches = relation_repair_patches(item)
+            if app_key and patches:
+                relation_repair_jobs.append({"item": item, "app_key": app_key, "patches": patches})
+
+        def run_relation_repair_job(job: JSONObject) -> JSONObject:
+            app_key = str(job.get("app_key") or "")
+            patches = list(job.get("patches") or [])
+            repair_started_at = time.perf_counter()
+            try:
+                repair_result = self._app_schema_apply_once(
+                    profile=profile,
+                    app_key=app_key,
+                    package_id=None,
+                    app_name="",
+                    app_title="",
+                    icon="",
+                    color="",
+                    visibility=None,
+                    publish=publish,
+                    add_fields=[],
+                    update_fields=patches,
+                    remove_fields=[],
+                    inline_form_layout_sections=None,
+                    allow_inline_layout_fallback=False,
+                )
+                public_repair = _publicize_package_fields(repair_result)
+            except Exception as error:  # pragma: no cover - defensive guard for unexpected worker failures
+                return {"job": job, "elapsed_ms": _elapsed_ms(repair_started_at), "exception": repr(error)}
+            return {
+                "job": job,
+                "elapsed_ms": _elapsed_ms(repair_started_at),
+                "public_repair": public_repair,
+            }
+
+        if relation_repair_jobs:
+            repair_phase_started_at = time.perf_counter()
+            repair_workers = worker_count(len(relation_repair_jobs))
+            repair_outputs: list[JSONObject] = []
+            with ThreadPoolExecutor(max_workers=repair_workers) as executor:
+                futures = [executor.submit(run_relation_repair_job, job) for job in relation_repair_jobs]
+                for future in as_completed(futures):
+                    repair_outputs.append(future.result())
+            relation_repair_ms += _elapsed_ms(repair_phase_started_at)
+            for output in repair_outputs:
+                job = output.get("job") if isinstance(output.get("job"), dict) else {}
+                original = job.get("item") if isinstance(job.get("item"), dict) else {}
+                if not original:
+                    continue
+                try:
+                    index = int(original.get("index"))
+                except (TypeError, ValueError):
+                    continue
+                if index < 0 or index >= len(final_items):
+                    continue
+                repaired_item = deepcopy(original)
+                exception = output.get("exception")
+                if exception:
+                    repaired_item["relation_repair"] = {
+                        "attempted": True,
+                        "status": "failed",
+                        "error_code": "RELATION_REPAIR_EXCEPTION",
+                        "message": str(exception),
+                    }
+                    final_items[index] = repaired_item
+                    continue
+                public_repair = output.get("public_repair") if isinstance(output.get("public_repair"), dict) else {}
+                merge_child_duration(public_repair)
+                if _schema_apply_result_has_write(public_repair):
+                    any_write_executed = True
+                if _schema_apply_result_may_have_write(public_repair):
+                    any_write_may_have_succeeded = True
+                repair_payload: JSONObject = {
+                    "attempted": True,
+                    "status": public_repair.get("status"),
+                    "error_code": public_repair.get("error_code"),
+                    "message": public_repair.get("message"),
+                    "verified": bool(public_repair.get("verified")),
+                    "field_diff": public_repair.get("field_diff") or {},
+                    **({"verification": public_repair.get("verification")} if isinstance(public_repair.get("verification"), dict) else {}),
+                    **({"details": public_repair.get("details")} if isinstance(public_repair.get("details"), dict) else {}),
+                    **({"duration_breakdown_ms": public_repair.get("duration_breakdown_ms")} if isinstance(public_repair.get("duration_breakdown_ms"), dict) else {}),
+                }
+                repaired_item["relation_repair"] = repair_payload
+                repaired_item["field_diff"] = _merge_schema_field_diffs(repaired_item.get("field_diff") or {}, public_repair.get("field_diff") or {})
+                repaired_item["field_diff_details"] = _merge_schema_field_diffs(
+                    repaired_item.get("field_diff_details") or {},
+                    public_repair.get("field_diff_details") or {},
+                )
+                if public_repair.get("status") == "success" and bool(public_repair.get("verified")):
+                    repaired_item["status"] = "success"
+                    repaired_item["error_code"] = None
+                    repaired_item["message"] = "applied schema patch; relation readback repaired"
+                    repaired_item["published"] = bool(public_repair.get("published"))
+                    repaired_item["verified"] = True
+                    original_verification = repaired_item.get("verification") if isinstance(repaired_item.get("verification"), dict) else {}
+                    repair_verification = public_repair.get("verification") if isinstance(public_repair.get("verification"), dict) else {}
+                    merged_verification = {**deepcopy(original_verification), **deepcopy(repair_verification)}
+                    repaired_item["verification"] = merged_verification
+                    details = repaired_item.get("details") if isinstance(repaired_item.get("details"), dict) else {}
+                    details = deepcopy(details)
+                    details.pop("relation_repair_plan", None)
+                    repaired_item["details"] = details
+                final_items[index] = repaired_item
 
         pending_readback = sum(1 for item in final_items if item.get("status") == "pending_readback")
         succeeded = sum(1 for item in final_items if item.get("status") in {"success", "partial_success"})
@@ -2096,6 +3188,7 @@ class AiBuilderTools(ToolBase):
             "package_id": package_id,
             "publish_requested": publish,
             "apps": final_items,
+            "parallelism": parallelism,
             "normalized_args": normalized_args,
             "verification": {
                 "all_apps_succeeded": failed == 0,
@@ -2116,7 +3209,69 @@ class AiBuilderTools(ToolBase):
             response["next_action"] = "readback_before_retry"
             response["pending_readback_app_keys"] = list(dict.fromkeys(pending_readback_app_keys))
             response["pending_readback_app_names"] = list(dict.fromkeys(pending_readback_app_names))
-        return response
+        return finish(response)
+
+    def _stabilize_deferred_relation_metadata(
+        self,
+        *,
+        profile: str,
+        source_app_key: str,
+        deferred_add_fields: list[JSONObject],
+        delay_seconds: float,
+    ) -> list[JSONObject]:
+        edit_context_result = self._finish_deferred_relation_edit_context(profile=profile, app_key=source_app_key)
+        time.sleep(delay_seconds)
+        app_keys = [source_app_key]
+        for key in _multi_app_relation_target_app_keys(deferred_add_fields):
+            if key and key not in app_keys:
+                app_keys.append(key)
+        readback: list[JSONObject] = []
+        for app_key in app_keys:
+            try:
+                result = self._facade.app_read_fields(profile=profile, app_key=app_key)
+                readback.append(
+                    {
+                        "app_key": app_key,
+                        "status": result.get("status"),
+                        "field_count": len(result.get("fields") or []),
+                        **({"edit_context": edit_context_result} if app_key == source_app_key else {}),
+                    }
+                )
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = _coerce_api_error(error)
+                readback.append(
+                    {
+                        "app_key": app_key,
+                        "status": "failed",
+                        "transport_error": {
+                            "http_status": api_error.http_status,
+                            "backend_code": api_error.backend_code,
+                            "category": api_error.category,
+                            "request_id": api_error.request_id,
+                        },
+                    }
+                )
+        return readback
+
+    def _finish_deferred_relation_edit_context(self, *, profile: str, app_key: str) -> JSONObject:
+        try:
+            version_result = self._facade.apps.app_get_edit_version_no(profile=profile, app_key=app_key).get("result") or {}
+            raw_version = version_result.get("editVersionNo") or version_result.get("versionNo") or 1
+            edit_version_no = int(raw_version)
+            self._facade.apps.app_edit_finished(profile=profile, app_key=app_key, payload={"editVersionNo": edit_version_no})
+            return {"status": "success", "edit_version_no": edit_version_no}
+        except (QingflowApiError, RuntimeError, TypeError, ValueError) as error:
+            api_error = _coerce_api_error(error if isinstance(error, (QingflowApiError, RuntimeError)) else RuntimeError(str(error)))
+            return {
+                "status": "failed",
+                "message": api_error.message,
+                "transport_error": {
+                    "http_status": api_error.http_status,
+                    "backend_code": api_error.backend_code,
+                    "category": api_error.category,
+                    "request_id": api_error.request_id,
+                },
+            }
 
     def _app_schema_apply_once(
         self,
@@ -2129,14 +3284,17 @@ class AiBuilderTools(ToolBase):
         icon: str = "",
         color: str = "",
         visibility: JSONObject | None = None,
-        create_if_missing: bool = False,
         publish: bool = True,
         add_fields: list[JSONObject],
         update_fields: list[JSONObject],
         remove_fields: list[JSONObject],
+        inline_form_layout_sections: list[JSONObject] | None = None,
+        allow_inline_layout_fallback: bool = True,
     ) -> JSONObject:
         """执行内部辅助逻辑。"""
+        started_at = time.perf_counter()
         effective_app_name = app_name or app_title
+        creating = not bool(str(app_key or "").strip()) and package_id is not None and bool(str(effective_app_name or "").strip())
         system_field_failure = _reserved_system_field_name_failure(
             tool_name="app_schema_apply",
             profile=profile,
@@ -2146,7 +3304,6 @@ class AiBuilderTools(ToolBase):
             icon=icon,
             color=color,
             visibility=visibility,
-            create_if_missing=create_if_missing,
             publish=publish,
             add_fields=add_fields,
             update_fields=update_fields,
@@ -2158,38 +3315,19 @@ class AiBuilderTools(ToolBase):
             tool_name="app_schema_apply",
             icon=icon,
             color=color,
-            creating=not bool(str(app_key or "").strip()) and bool(create_if_missing),
+            creating=creating,
         )
         if icon_failure is not None:
             return icon_failure
-        plan_result = self._rewrite_plan_result_for_apply(
-            result=self.app_schema_plan(
-                profile=profile,
-                app_key=app_key,
-                package_id=package_id,
-                app_name=effective_app_name,
-                icon=icon,
-                color=color,
-                visibility=visibility,
-                create_if_missing=create_if_missing,
-                add_fields=add_fields,
-                update_fields=update_fields,
-                remove_fields=remove_fields,
-            ),
-            profile=profile,
-            publish=publish,
-            plan_tool_name="app_schema_plan",
-            apply_tool_name="app_schema_apply",
-        )
-        if not isinstance(plan_result, dict) or plan_result.get("status") != "success":
-            return plan_result
-        plan_args = plan_result.get("normalized_args")
-        if not isinstance(plan_args, dict):
-            plan_args = {}
         try:
-            parsed_add = [FieldPatch.model_validate(item) for item in plan_args.get("add_fields") or []]
-            parsed_update = [FieldUpdatePatch.model_validate(item) for item in plan_args.get("update_fields") or []]
-            parsed_remove = [FieldRemovePatch.model_validate(item) for item in plan_args.get("remove_fields") or []]
+            parsed_add = [FieldPatch.model_validate(item) for item in add_fields or []]
+            parsed_update = [FieldUpdatePatch.model_validate(item) for item in update_fields or []]
+            parsed_remove = [FieldRemovePatch.model_validate(item) for item in remove_fields or []]
+            parsed_inline_layout = [
+                LayoutSectionPatch.model_validate(item)
+                for item in (inline_form_layout_sections or [])
+            ]
+            parsed_visibility = VisibilityPatch.model_validate(visibility) if visibility is not None else None
         except ValidationError as exc:
             return _validation_failure(
                 str(exc),
@@ -2199,57 +3337,170 @@ class AiBuilderTools(ToolBase):
                     "tool_name": "app_schema_apply",
                     "arguments": {
                         "profile": profile,
-                        "app_key": str(plan_args.get("app_key") or app_key),
-                        "package_id": plan_args.get("package_id", package_id),
-                        "app_name": str(plan_args.get("app_name") or effective_app_name),
-                        "icon": str(plan_args.get("icon") or icon),
-                        "color": str(plan_args.get("color") or color),
-                        "visibility": plan_args.get("visibility") or visibility,
-                        "create_if_missing": bool(plan_args.get("create_if_missing", create_if_missing)),
+                        "app_key": str(app_key or ""),
+                        "package_id": package_id,
+                        "app_name": effective_app_name,
+                        "icon": str(icon or ""),
+                        "color": str(color or ""),
+                        "visibility": visibility,
                         "publish": publish,
-                        "add_fields": plan_args.get("add_fields") or [{"name": "字段名称", "type": "text", "required": False}],
-                        "update_fields": plan_args.get("update_fields") or [],
-                        "remove_fields": plan_args.get("remove_fields") or [],
+                        "add_fields": add_fields or [{"name": "字段名称", "type": "text", "required": False}],
+                        "update_fields": update_fields or [],
+                        "remove_fields": remove_fields or [],
                     },
                 },
             )
         normalized_args = {
-            "app_key": str(plan_args.get("app_key") or app_key),
-            "package_id": plan_args.get("package_id", package_id),
-            "app_name": str(plan_args.get("app_name") or effective_app_name),
-            "icon": str(plan_args.get("icon") or icon or ""),
-            "color": str(plan_args.get("color") or color or ""),
-            "visibility": plan_args.get("visibility") or visibility,
-            "create_if_missing": bool(plan_args.get("create_if_missing", create_if_missing)),
+            "app_key": str(app_key or ""),
+            "package_id": package_id,
+            "app_name": effective_app_name,
+            "icon": str(icon or ""),
+            "color": str(color or ""),
+            "visibility": parsed_visibility.model_dump(mode="json") if parsed_visibility is not None else None,
             "publish": publish,
             "add_fields": [patch.model_dump(mode="json") for patch in parsed_add],
             "update_fields": [patch.model_dump(mode="json") for patch in parsed_update],
             "remove_fields": [patch.model_dump(mode="json") for patch in parsed_remove],
+            **(
+                {
+                    "inline_form_layout_sections": [
+                        section.model_dump(mode="json", exclude_none=True)
+                        for section in parsed_inline_layout
+                    ]
+                }
+                if parsed_inline_layout
+                else {}
+            ),
         }
         result = _safe_tool_call(
             lambda: self._facade.app_schema_apply(
                 profile=profile,
-                app_key=str(plan_args.get("app_key") or app_key),
-                package_tag_id=plan_args.get("package_id", package_id),
-                app_name=str(plan_args.get("app_name") or effective_app_name),
-                icon=str(plan_args.get("icon") or icon or ""),
-                color=str(plan_args.get("color") or color or ""),
-                visibility=VisibilityPatch.model_validate(plan_args.get("visibility")) if plan_args.get("visibility") is not None else None,
-                create_if_missing=bool(plan_args.get("create_if_missing", create_if_missing)),
+                app_key=str(app_key or ""),
+                package_tag_id=package_id,
+                app_name=effective_app_name,
+                icon=str(icon or ""),
+                color=str(color or ""),
+                visibility=parsed_visibility,
                 publish=publish,
                 add_fields=parsed_add,
                 update_fields=parsed_update,
                 remove_fields=parsed_remove,
+                inline_form_layout_sections=parsed_inline_layout,
             ),
             error_code="SCHEMA_APPLY_FAILED",
             normalized_args=normalized_args,
             suggested_next_call={"tool_name": "app_schema_apply", "arguments": {"profile": profile, **normalized_args}},
         )
-        return _publicize_package_fields(result)
+        public_result = _publicize_package_fields(result)
+        if inline_form_layout_sections and allow_inline_layout_fallback and not _inline_form_layout_was_handled(public_result):
+            layout_started_at = time.perf_counter()
+            public_result = self._apply_inline_form_layout_after_schema(
+                profile=profile,
+                schema_result=public_result,
+                fallback_app_key=str(app_key or ""),
+                publish=publish,
+                sections=inline_form_layout_sections,
+            )
+            _merge_duration_breakdown(
+                public_result,
+                inline_layout_ms=_elapsed_ms(layout_started_at),
+            )
+        _merge_duration_breakdown(public_result, total_ms=_elapsed_ms(started_at))
+        return public_result
+
+    def _apply_inline_form_layout_after_schema(
+        self,
+        *,
+        profile: str,
+        schema_result: JSONObject,
+        fallback_app_key: str = "",
+        publish: bool,
+        sections: list[JSONObject],
+    ) -> JSONObject:
+        result = deepcopy(schema_result)
+        if not sections:
+            return result
+        app_key = str(result.get("app_key") or result.get("appKey") or fallback_app_key or "").strip()
+        result["inline_form_layout"] = {
+            "requested": True,
+            "section_count": len(sections),
+            "applied": False,
+        }
+        if result.get("status") not in {"success", "partial_success"}:
+            result["inline_form_layout"]["skipped_reason"] = "schema_apply_failed"
+            verification = result.get("verification") if isinstance(result.get("verification"), dict) else {}
+            verification = deepcopy(verification)
+            verification["inline_form_layout_verified"] = False
+            result["verification"] = verification
+            return result
+        if not app_key:
+            result["status"] = "partial_success"
+            result["error_code"] = result.get("error_code") or "INLINE_FORM_LAYOUT_APP_KEY_MISSING"
+            result["message"] = "schema applied but inline form layout could not run because app_key was not resolved"
+            result["inline_form_layout"]["error_code"] = "INLINE_FORM_LAYOUT_APP_KEY_MISSING"
+            verification = result.get("verification") if isinstance(result.get("verification"), dict) else {}
+            verification = deepcopy(verification)
+            verification["inline_form_layout_verified"] = False
+            result["verification"] = verification
+            result["safe_to_retry"] = False
+            return result
+        layout_result = self._app_layout_apply_once(
+            profile=profile,
+            app_key=app_key,
+            mode="merge",
+            publish=publish,
+            sections=sections,
+        )
+        layout_ok = isinstance(layout_result, dict) and layout_result.get("status") in {"success", "partial_success"}
+        result["inline_form_layout"] = {
+            "requested": True,
+            "section_count": len(sections),
+            "app_key": app_key,
+            "applied": layout_ok,
+            "layout_status": layout_result.get("status") if isinstance(layout_result, dict) else "failed",
+            **({"error_code": layout_result.get("error_code")} if isinstance(layout_result, dict) and layout_result.get("error_code") else {}),
+            **({"message": layout_result.get("message")} if isinstance(layout_result, dict) and layout_result.get("message") else {}),
+        }
+        result["inline_form_layout_result"] = layout_result
+        verification = result.get("verification") if isinstance(result.get("verification"), dict) else {}
+        verification = deepcopy(verification)
+        verification["inline_form_layout_verified"] = layout_ok
+        result["verification"] = verification
+        if layout_ok:
+            result["write_executed"] = True
+            return result
+        result["status"] = "partial_success" if result.get("status") == "success" else result.get("status", "partial_success")
+        result["error_code"] = result.get("error_code") or "INLINE_FORM_LAYOUT_APPLY_FAILED"
+        result["message"] = "schema applied but inline form layout failed"
+        result["safe_to_retry"] = False
+        return result
 
     @tool_cn_name("应用布局应用")
-    def app_layout_apply(self, *, profile: str, app_key: str, mode: str = "merge", publish: bool = True, sections: list[JSONObject]) -> JSONObject:
+    def app_layout_apply(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        mode: str = "merge",
+        publish: bool = True,
+        sections: list[JSONObject],
+        apps: list[JSONObject] | None = None,
+    ) -> JSONObject:
         """执行应用相关逻辑。"""
+        if apps is not None:
+            return self._apply_app_batch(
+                tool_name="app_layout_apply",
+                profile=profile,
+                apps=apps,
+                apply_one=lambda _index, item, item_app_key: self.app_layout_apply(
+                    profile=profile,
+                    app_key=item_app_key,
+                    mode=str(_payload_get(item, "mode", default=mode) or mode),
+                    publish=_payload_bool(item, "publish", default=publish),
+                    sections=_payload_list(item, "sections", default=sections or []),
+                    apps=None,
+                ),
+            )
         result = self._app_layout_apply_once(
             profile=profile,
             app_key=app_key,
@@ -2272,27 +3523,9 @@ class AiBuilderTools(ToolBase):
 
     def _app_layout_apply_once(self, *, profile: str, app_key: str, mode: str = "merge", publish: bool = True, sections: list[JSONObject]) -> JSONObject:
         """执行内部辅助逻辑。"""
-        plan_result = self._rewrite_plan_result_for_apply(
-            result=self.app_layout_plan(
-                profile=profile,
-                app_key=app_key,
-                mode=mode,
-                sections=sections,
-                preset=None,
-            ),
-            profile=profile,
-            publish=publish,
-            plan_tool_name="app_layout_plan",
-            apply_tool_name="app_layout_apply",
-        )
-        if not isinstance(plan_result, dict) or plan_result.get("status") != "success":
-            return plan_result
-        plan_args = plan_result.get("normalized_args")
-        if not isinstance(plan_args, dict):
-            plan_args = {}
         try:
-            parsed_mode = LayoutApplyMode(str(plan_args.get("mode") or mode))
-            parsed_sections = [LayoutSectionPatch.model_validate(item) for item in plan_args.get("sections") or []]
+            parsed_mode = LayoutApplyMode(str(mode or "merge"))
+            parsed_sections = [LayoutSectionPatch.model_validate(item) for item in sections or []]
         except (ValueError, ValidationError) as exc:
             return _validation_failure(
                 str(exc),
@@ -2302,15 +3535,15 @@ class AiBuilderTools(ToolBase):
                     "tool_name": "app_layout_apply",
                     "arguments": {
                         "profile": profile,
-                        "app_key": str(plan_args.get("app_key") or app_key),
-                        "mode": str(plan_args.get("mode") or "merge"),
+                        "app_key": app_key,
+                        "mode": str(mode or "merge"),
                         "publish": publish,
-                        "sections": plan_args.get("sections") or [{"title": "基础信息", "rows": [["字段A", "字段B"]]}],
+                        "sections": sections or [{"title": "基础信息", "rows": [["字段A", "字段B"]]}],
                     },
                 },
             )
         normalized_args = {
-            "app_key": str(plan_args.get("app_key") or app_key),
+            "app_key": app_key,
             "mode": parsed_mode.value,
             "publish": publish,
             "sections": [section.model_dump(mode="json", exclude_none=True) for section in parsed_sections],
@@ -2318,7 +3551,7 @@ class AiBuilderTools(ToolBase):
         return _safe_tool_call(
             lambda: self._facade.app_layout_apply(
                 profile=profile,
-                app_key=str(plan_args.get("app_key") or app_key),
+                app_key=app_key,
                 mode=parsed_mode,
                 publish=publish,
                 sections=parsed_sections,
@@ -2334,51 +3567,148 @@ class AiBuilderTools(ToolBase):
         *,
         profile: str,
         app_key: str,
-        spec: JSONObject,
+        mode: str | None = None,
         publish: bool = True,
+        nodes: list[JSONObject] | None = None,
+        transitions: list[JSONObject] | None = None,
+        spec: JSONObject | None = None,
         idempotency_key: str | None = None,
         schema_version: str | None = None,
+        patch_nodes: list[JSONObject] | None = None,
     ) -> JSONObject:
         """执行应用相关逻辑。"""
-        if not isinstance(spec, dict) or not spec:
-            return _config_failure(
+        if patch_nodes is not None:
+            normalized_args = {
+                "app_key": app_key,
+                "publish": publish,
+                "patch_nodes": patch_nodes,
+                "idempotency_key": idempotency_key,
+                "schema_version": schema_version,
+            }
+            return _attach_builder_apply_envelope("app_flow_apply", _safe_tool_call(
+                lambda: self._facade.flow_patch_nodes(
+                    profile=profile,
+                    app_key=app_key,
+                    patch_nodes=patch_nodes,
+                    publish=publish,
+                    idempotency_key=idempotency_key,
+                    schema_version=schema_version,
+                ),
+                error_code="FLOW_PATCH_FAILED",
+                normalized_args=normalized_args,
+                suggested_next_call={"tool_name": "app_flow_get", "arguments": {"profile": profile, "app_key": app_key}},
+            ))
+        if spec is not None:
+            normalized_args = {
+                "app_key": app_key,
+                "publish": publish,
+                "spec": spec,
+                "idempotency_key": idempotency_key,
+                "schema_version": schema_version,
+            }
+            return _attach_builder_apply_envelope("app_flow_apply", _safe_tool_call(
+                lambda: self._facade.flow_apply(
+                    profile=profile,
+                    app_key=app_key,
+                    spec=spec,
+                    publish=publish,
+                    idempotency_key=idempotency_key,
+                    schema_version=schema_version,
+                ),
+                error_code="FLOW_SPEC_APPLY_FAILED",
+                normalized_args=normalized_args,
+                suggested_next_call={"tool_name": "app_flow_get", "arguments": {"profile": profile, "app_key": app_key}},
+            ))
+        if nodes or transitions:
+            effective_nodes = nodes or []
+            effective_transitions = transitions or []
+            result = self._app_flow_apply_once(
+                profile=profile,
+                app_key=app_key,
+                mode=mode or "replace",
+                publish=publish,
+                nodes=effective_nodes,
+                transitions=effective_transitions,
+            )
+            result = self._retry_after_self_lock_release(
+                profile=profile,
+                result=result,
+                retry_call=lambda: self._app_flow_apply_once(
+                    profile=profile,
+                    app_key=app_key,
+                    mode=mode or "replace",
+                    publish=publish,
+                    nodes=effective_nodes,
+                    transitions=effective_transitions,
+                ),
+            )
+            return _attach_builder_apply_envelope("app_flow_apply", result)
+        normalized_args = {"app_key": app_key, "publish": publish}
+        return _attach_builder_apply_envelope("app_flow_apply", _failed(
+            "FLOW_SPEC_OR_PATCH_REQUIRED",
+            "app_flow_apply requires spec for a complete WorkflowSpec write or patch_nodes for targeted edits.",
+            normalized_args=normalized_args,
+            suggested_next_call={"tool_name": "app_flow_get_schema", "arguments": {"profile": profile}},
+        ))
+
+    def _app_flow_apply_once(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        mode: str = "replace",
+        publish: bool = True,
+        nodes: list[JSONObject],
+        transitions: list[JSONObject],
+    ) -> JSONObject:
+        """执行内部辅助逻辑。"""
+        try:
+            request = FlowPlanRequest.model_validate(
+                {
+                    "app_key": app_key,
+                    "mode": mode,
+                    "nodes": nodes or [],
+                    "transitions": transitions or [],
+                    "preset": None,
+                }
+            )
+        except ValidationError as exc:
+            return _validation_failure(
+                str(exc),
                 tool_name="app_flow_apply",
-                message="app_flow_apply requires a non-empty WorkflowSpecDTO `spec` object.",
-                fix_hint="Call app_flow_get_schema, then app_flow_get for GET-first baseline, patch spec, and apply.",
+                exc=exc,
+                suggested_next_call={
+                    "tool_name": "app_flow_apply",
+                    "arguments": {
+                        "profile": profile,
+                        "app_key": app_key,
+                        "mode": str(mode or "replace"),
+                        "publish": publish,
+                        "nodes": nodes or [{"id": "start", "type": "start", "name": "发起"}],
+                        "transitions": transitions or [],
+                    },
+                },
             )
         normalized_args = {
-            "app_key": app_key,
+            "app_key": request.app_key,
+            "mode": request.mode,
             "publish": publish,
-            "spec": spec,
-            "idempotency_key": idempotency_key,
-            "schema_version": schema_version,
+            "nodes": [node.model_dump(mode="json") for node in request.nodes],
+            "transitions": [transition.model_dump(mode="json", by_alias=True) for transition in request.transitions],
         }
-        result = _safe_tool_call(
-            lambda: self._facade.flow_apply(
+        return _safe_tool_call(
+            lambda: self._facade.app_flow_apply(
                 profile=profile,
-                app_key=app_key,
-                spec=spec,
+                app_key=request.app_key,
+                mode=request.mode,
                 publish=publish,
-                idempotency_key=idempotency_key,
-                schema_version=schema_version,
+                nodes=[node.model_dump(mode="json") for node in request.nodes],
+                transitions=[transition.model_dump(mode="json", by_alias=True) for transition in request.transitions],
             ),
             error_code="FLOW_APPLY_FAILED",
             normalized_args=normalized_args,
             suggested_next_call={"tool_name": "app_flow_apply", "arguments": {"profile": profile, **normalized_args}},
         )
-        result = self._retry_after_self_lock_release(
-            profile=profile,
-            result=result,
-            retry_call=lambda: self._facade.flow_apply(
-                profile=profile,
-                app_key=app_key,
-                spec=spec,
-                publish=publish,
-                idempotency_key=idempotency_key,
-                schema_version=schema_version,
-            ),
-        )
-        return _attach_builder_apply_envelope("app_flow_apply", result)
 
     @tool_cn_name("应用视图应用")
     def app_views_apply(
@@ -2390,8 +3720,31 @@ class AiBuilderTools(ToolBase):
         upsert_views: list[JSONObject],
         patch_views: list[JSONObject] | None = None,
         remove_views: list[str],
+        apps: list[JSONObject] | None = None,
+        views: list[JSONObject] | None = None,
     ) -> JSONObject:
         """执行应用相关逻辑。"""
+        if views is not None:
+            return self._app_views_apply_view_batch(
+                profile=profile,
+                publish=publish,
+                views=views,
+            )
+        if apps is not None:
+            return self._apply_app_batch(
+                tool_name="app_views_apply",
+                profile=profile,
+                apps=apps,
+                apply_one=lambda _index, item, item_app_key: self.app_views_apply(
+                    profile=profile,
+                    app_key=item_app_key,
+                    publish=_payload_bool(item, "publish", default=publish),
+                    upsert_views=_payload_list(item, "upsert_views", "upsertViews", "views", default=upsert_views or []),
+                    patch_views=_payload_list(item, "patch_views", "patchViews", default=patch_views or []),
+                    remove_views=_payload_list(item, "remove_views", "removeViews", default=remove_views or []),
+                    apps=None,
+                ),
+            )
         result = self._app_views_apply_once(
             profile=profile,
             app_key=app_key,
@@ -2414,6 +3767,248 @@ class AiBuilderTools(ToolBase):
         )
         return _attach_builder_apply_envelope("app_views_apply", result)
 
+    def _app_views_apply_view_batch(
+        self,
+        *,
+        profile: str,
+        publish: bool,
+        views: list[JSONObject],
+    ) -> JSONObject:
+        started_at = time.perf_counter()
+        if not isinstance(views, list) or not views:
+            return _attach_builder_apply_envelope(
+                "app_views_apply",
+                _config_failure(
+                    tool_name="app_views_apply",
+                    message="app_views_apply views[] batch mode requires a non-empty views array.",
+                    fix_hint="Pass views as a JSON array; each item must include app_key and operation.",
+                    details={"expected_shape": {"views": [{"operation": "upsert", "app_key": "APP_KEY", "name": "业务视图", "type": "table", "columns": ["字段A"]}]}},
+                ),
+            )
+
+        def _infer_operation(item: JSONObject) -> str:
+            raw = str(item.get("operation") or item.get("op") or "").strip().lower()
+            aliases = {
+                "create": "upsert",
+                "update": "upsert",
+                "replace": "upsert",
+                "delete": "remove",
+                "remove": "remove",
+                "patch": "patch",
+                "upsert": "upsert",
+            }
+            if raw:
+                return aliases.get(raw, raw)
+            if "set" in item or "unset" in item or "update" in item or "values" in item:
+                return "patch"
+            if "view_key" in item or "viewKey" in item:
+                return "patch" if ("name" in item or "type" in item or "columns" in item or "fields" in item) else "remove"
+            return "upsert"
+
+        def _view_job_payload(item: JSONObject) -> JSONObject:
+            return {
+                key: deepcopy(value)
+                for key, value in item.items()
+                if key
+                not in {
+                    "operation",
+                    "op",
+                    "app_key",
+                    "appKey",
+                    "publish",
+                }
+            }
+
+        def _view_selector(payload: JSONObject) -> str:
+            return str(payload.get("view_key") or payload.get("viewKey") or payload.get("viewgraphKey") or payload.get("viewGraphKey") or payload.get("name") or "").strip()
+
+        normalized_jobs: list[JSONObject] = []
+        job_results: list[JSONObject | None] = [None for _ in views]
+        errors: list[JSONObject] = []
+        seen_patch_remove: dict[tuple[str, str], int] = {}
+        seen_upsert_names: dict[tuple[str, str], int] = {}
+
+        def _add_validation_error(index: int, error_code: str, message: str, *, app_key: str = "", operation: str = "", reason_path: str = "") -> None:
+            error = {
+                "index": index,
+                "app_key": app_key,
+                "operation": operation,
+                "status": "failed",
+                "error_code": error_code,
+                "message": message,
+                **({"reason_path": reason_path} if reason_path else {}),
+            }
+            errors.append(error)
+            job_results[index] = error
+
+        for index, item in enumerate(views):
+            if not isinstance(item, dict):
+                _add_validation_error(index, "VIEWS_FILE_ITEM_INVALID", "views[] item must be an object", reason_path=f"views[{index}]")
+                continue
+            app_key = str(item.get("app_key") or item.get("appKey") or "").strip()
+            operation = _infer_operation(item)
+            payload = _view_job_payload(item)
+            if not app_key:
+                _add_validation_error(index, "VIEWS_FILE_APP_KEY_REQUIRED", "views[] item requires app_key", operation=operation, reason_path=f"views[{index}].app_key")
+                continue
+            if operation not in {"upsert", "patch", "remove"}:
+                _add_validation_error(index, "VIEWS_FILE_OPERATION_INVALID", "views[].operation must be upsert, patch, or remove", app_key=app_key, operation=operation, reason_path=f"views[{index}].operation")
+                continue
+            selector = _view_selector(payload)
+            if operation in {"patch", "remove"} and not selector:
+                _add_validation_error(index, "VIEWS_FILE_VIEW_SELECTOR_REQUIRED", f"{operation} view job requires view_key or name", app_key=app_key, operation=operation, reason_path=f"views[{index}].view_key")
+                continue
+            if operation in {"patch", "remove"} and selector:
+                conflict_key = (app_key, selector)
+                first_index = seen_patch_remove.get(conflict_key)
+                if first_index is not None:
+                    _add_validation_error(index, "DUPLICATE_VIEW_JOB_CONFLICT", f"views[{index}] conflicts with views[{first_index}] for the same app/view selector", app_key=app_key, operation=operation, reason_path=f"views[{index}]")
+                    continue
+                seen_patch_remove[conflict_key] = index
+            if operation == "upsert":
+                name = str(payload.get("name") or "").strip()
+                if name:
+                    conflict_key = (app_key, name)
+                    first_index = seen_upsert_names.get(conflict_key)
+                    if first_index is not None:
+                        _add_validation_error(index, "DUPLICATE_VIEW_NAME_IN_BATCH", f"views[{index}] duplicates upsert view name from views[{first_index}] in the same app", app_key=app_key, operation=operation, reason_path=f"views[{index}].name")
+                        continue
+                    seen_upsert_names[conflict_key] = index
+            normalized_jobs.append(
+                {
+                    "index": index,
+                    "app_key": app_key,
+                    "operation": operation,
+                    "publish": _payload_bool(item, "publish", default=publish),
+                    "payload": payload,
+                }
+            )
+
+        def _extract_view_identity(result: JSONObject, fallback_payload: JSONObject, fallback_operation: str) -> tuple[str | None, str | None, str]:
+            diff = result.get("views_diff") if isinstance(result.get("views_diff"), dict) else {}
+            for key, operation_name in (("created", "created"), ("updated", "updated"), ("removed", "removed"), ("failed", "failed")):
+                entries = diff.get(key)
+                if isinstance(entries, list) and entries:
+                    entry = entries[0]
+                    if isinstance(entry, dict):
+                        return (
+                            str(entry.get("name") or entry.get("view_name") or entry.get("viewName") or fallback_payload.get("name") or "").strip() or None,
+                            str(entry.get("view_key") or entry.get("viewKey") or fallback_payload.get("view_key") or fallback_payload.get("viewKey") or "").strip() or None,
+                            operation_name,
+                        )
+                    if entry not in (None, ""):
+                        return (str(entry), None, operation_name)
+            fallback_name = str(fallback_payload.get("name") or "").strip() or None
+            fallback_view_key = str(fallback_payload.get("view_key") or fallback_payload.get("viewKey") or "").strip() or None
+            return fallback_name, fallback_view_key, "removed" if fallback_operation == "remove" else "updated"
+
+        def _run_view_job(job: JSONObject) -> JSONObject:
+            payload = deepcopy(job["payload"])
+            operation = str(job["operation"])
+            app_key = str(job["app_key"])
+            job_publish = bool(job.get("publish"))
+            if operation == "upsert":
+                call_kwargs = {"upsert_views": [payload], "patch_views": [], "remove_views": []}
+            elif operation == "patch":
+                call_kwargs = {"upsert_views": [], "patch_views": [payload], "remove_views": []}
+            else:
+                call_kwargs = {"upsert_views": [], "patch_views": [], "remove_views": [_view_selector(payload)]}
+            result = self._app_views_apply_once(
+                profile=profile,
+                app_key=app_key,
+                publish=job_publish,
+                **call_kwargs,
+            )
+            result = self._retry_after_self_lock_release(
+                profile=profile,
+                result=result,
+                retry_call=lambda: self._app_views_apply_once(
+                    profile=profile,
+                    app_key=app_key,
+                    publish=job_publish,
+                    **call_kwargs,
+                ),
+            )
+            status = str(result.get("status") or "success") if isinstance(result, dict) else "failed"
+            name, view_key, actual_operation = _extract_view_identity(result if isinstance(result, dict) else {}, payload, operation)
+            item: JSONObject = {
+                "index": job["index"],
+                "app_key": app_key,
+                "operation": actual_operation if status != "failed" else operation,
+                "requested_operation": operation,
+                "status": status,
+                **({"name": name} if name else {}),
+                **({"view_key": view_key} if view_key else {}),
+                "result": result if isinstance(result, dict) else {"status": "failed", "message": str(result)},
+            }
+            if status == "failed":
+                item["error_code"] = item["result"].get("error_code")
+                item["message"] = item["result"].get("message")
+            return item
+
+        view_write_started_at = time.perf_counter()
+        view_workers = min(VIEW_APPLY_PARALLEL_LIMIT, len(normalized_jobs)) if normalized_jobs else 0
+        if normalized_jobs:
+            with ThreadPoolExecutor(max_workers=view_workers) as executor:
+                future_map = {executor.submit(_run_view_job, job): job for job in normalized_jobs}
+                for future in as_completed(future_map):
+                    job = future_map[future]
+                    try:
+                        item_result = future.result()
+                    except (QingflowApiError, RuntimeError) as error:
+                        api_error = _coerce_api_error(error)
+                        item_result = {
+                            "index": job["index"],
+                            "app_key": job["app_key"],
+                            "operation": job["operation"],
+                            "requested_operation": job["operation"],
+                            "status": "failed",
+                            "error_code": "VIEW_BATCH_JOB_FAILED",
+                            "message": _public_error_message("VIEW_BATCH_JOB_FAILED", api_error),
+                            "details": {"transport_error": _transport_error_payload(api_error)},
+                            "request_id": api_error.request_id,
+                            "backend_code": api_error.backend_code,
+                            "http_status": None if api_error.http_status == 404 else api_error.http_status,
+                        }
+                    job_results[int(job["index"])] = item_result
+        view_write_parallel_wall_ms = _elapsed_ms(view_write_started_at)
+
+        final_views = [item if isinstance(item, dict) else {"index": index, "status": "failed", "error_code": "VIEW_BATCH_JOB_MISSING", "message": "view batch job did not produce a result"} for index, item in enumerate(job_results)]
+        errors.extend(item for item in final_views if str(item.get("status") or "") == "failed" and item not in errors)
+        partial = sum(1 for item in final_views if str(item.get("status") or "") == "partial_success")
+        succeeded = sum(1 for item in final_views if str(item.get("status") or "") in {"success", "partial_success"})
+        failed = len(final_views) - succeeded
+        status = "failed" if succeeded == 0 else "partial_success" if failed > 0 or partial > 0 else "success"
+        write_executed = any(
+            isinstance(item.get("result"), dict) and bool(item["result"].get("write_executed"))
+            for item in final_views
+        )
+        payload: JSONObject = {
+            "status": status,
+            "error_code": None if status == "success" else "APP_VIEWS_APPLY_BATCH_PARTIAL" if succeeded else "APP_VIEWS_APPLY_BATCH_FAILED",
+            "recoverable": failed > 0 or partial > 0,
+            "message": f"applied app_views_apply to {succeeded}/{len(final_views)} views" if status != "success" else f"applied app_views_apply to {succeeded} views",
+            "normalized_args": {"views": views},
+            "views": final_views,
+            "errors": errors,
+            "parallelism": {"view_workers": view_workers, "same_app_parallel": True},
+            "verification": {
+                "batch_verified": failed == 0 and partial == 0,
+                "succeeded": succeeded,
+                "partial": partial,
+                "failed": failed,
+            },
+            "write_executed": write_executed,
+            "write_succeeded": write_executed and failed == 0 and partial == 0,
+            "safe_to_retry": not write_executed,
+        }
+        _merge_duration_breakdown(
+            payload,
+            view_write_parallel_wall_ms=view_write_parallel_wall_ms,
+            total_ms=_elapsed_ms(started_at),
+        )
+        return _attach_builder_apply_envelope("app_views_apply", payload)
+
     def _app_views_apply_once(
         self,
         *,
@@ -2428,77 +4023,17 @@ class AiBuilderTools(ToolBase):
         reserved_failure = _reserved_system_view_name_failure(
             tool_name="app_views_apply",
             profile=profile,
-            app_key=app_key,
-            publish=publish,
-            upsert_views=upsert_views,
-            patch_views=patch_views,
-            remove_views=remove_views,
-        )
-        if reserved_failure is not None:
-            return reserved_failure
-        if patch_views:
-            try:
-                parsed_views = [ViewUpsertPatch.model_validate(item) for item in (upsert_views or [])]
-                parsed_patch_views = [ViewPartialPatch.model_validate(item) for item in patch_views]
-            except ValidationError as exc:
-                return _visibility_validation_failure(
-                    str(exc),
-                    tool_name="app_views_apply",
-                    exc=exc,
-                    suggested_next_call={
-                        "tool_name": "app_views_apply",
-                        "arguments": {
-                            "profile": profile,
-                            "app_key": app_key,
-                            "publish": publish,
-                            "upsert_views": upsert_views or [],
-                            "patch_views": [
-                                {"view_key": "VIEW_KEY", "set": {"query_conditions": {"enabled": True, "rows": [["字段A"]]}}},
-                            ],
-                            "remove_views": remove_views or [],
-                        },
-                    },
-                )
-            normalized_args = {
-                "app_key": app_key,
-                "publish": publish,
-                "upsert_views": [view.model_dump(mode="json") for view in parsed_views],
-                "patch_views": [patch.model_dump(mode="json") for patch in parsed_patch_views],
-                "remove_views": list(remove_views or []),
-            }
-            return _safe_tool_call(
-                lambda: self._facade.app_views_apply(
-                    profile=profile,
-                    app_key=app_key,
-                    publish=publish,
-                    upsert_views=parsed_views,
-                    patch_views=parsed_patch_views,
-                    remove_views=list(remove_views or []),
-                ),
-                error_code="VIEWS_APPLY_FAILED",
-                normalized_args=normalized_args,
-                suggested_next_call={"tool_name": "app_views_apply", "arguments": {"profile": profile, **normalized_args}},
-            )
-        plan_result = self._rewrite_plan_result_for_apply(
-            result=self.app_views_plan(
-                profile=profile,
-                app_key=app_key,
-                upsert_views=upsert_views,
-                remove_views=remove_views,
-                preset=None,
-            ),
-            profile=profile,
+            app_key=app_key,
             publish=publish,
-            plan_tool_name="app_views_plan",
-            apply_tool_name="app_views_apply",
+            upsert_views=upsert_views,
+            patch_views=patch_views,
+            remove_views=remove_views,
         )
-        if not isinstance(plan_result, dict) or plan_result.get("status") != "success":
-            return plan_result
-        plan_args = plan_result.get("normalized_args")
-        if not isinstance(plan_args, dict):
-            plan_args = {}
+        if reserved_failure is not None:
+            return reserved_failure
         try:
-            parsed_views = [ViewUpsertPatch.model_validate(item) for item in plan_args.get("upsert_views") or []]
+            parsed_views = [ViewUpsertPatch.model_validate(item) for item in (upsert_views or [])]
+            parsed_patch_views = [ViewPartialPatch.model_validate(item) for item in (patch_views or [])]
         except ValidationError as exc:
             return _visibility_validation_failure(
                 str(exc),
@@ -2508,27 +4043,29 @@ class AiBuilderTools(ToolBase):
                     "tool_name": "app_views_apply",
                     "arguments": {
                         "profile": profile,
-                        "app_key": str(plan_args.get("app_key") or app_key),
+                        "app_key": app_key,
                         "publish": publish,
-                        "upsert_views": plan_args.get("upsert_views") or [{"name": "业务台账视图", "type": "table", "columns": ["字段A"]}],
-                        "remove_views": plan_args.get("remove_views") or [],
+                        "upsert_views": upsert_views or [{"name": "业务台账视图", "type": "table", "columns": ["字段A"]}],
+                        "patch_views": patch_views or [],
+                        "remove_views": remove_views or [],
                     },
                 },
             )
         normalized_args = {
-            "app_key": str(plan_args.get("app_key") or app_key),
+            "app_key": app_key,
             "publish": publish,
-            "upsert_views": [view.model_dump(mode="json") for view in parsed_views],
-            "remove_views": list(plan_args.get("remove_views") or remove_views),
+            "upsert_views": [public_view_upsert_payload(view) for view in parsed_views],
+            "patch_views": [public_view_partial_payload(patch) for patch in parsed_patch_views],
+            "remove_views": list(remove_views or []),
         }
         return _safe_tool_call(
             lambda: self._facade.app_views_apply(
                 profile=profile,
-                app_key=str(plan_args.get("app_key") or app_key),
+                app_key=app_key,
                 publish=publish,
                 upsert_views=parsed_views,
-                patch_views=[],
-                remove_views=list(plan_args.get("remove_views") or remove_views),
+                patch_views=parsed_patch_views,
+                remove_views=list(remove_views or []),
             ),
             error_code="VIEWS_APPLY_FAILED",
             normalized_args=normalized_args,
@@ -2566,8 +4103,24 @@ class AiBuilderTools(ToolBase):
         remove_chart_ids: list[str],
         reorder_chart_ids: list[str],
         patch_charts: list[JSONObject] | None = None,
+        apps: list[JSONObject] | None = None,
     ) -> JSONObject:
         """执行应用相关逻辑。"""
+        if apps is not None:
+            return self._apply_app_batch(
+                tool_name="app_charts_apply",
+                profile=profile,
+                apps=apps,
+                apply_one=lambda _index, item, item_app_key: self.app_charts_apply(
+                    profile=profile,
+                    app_key=item_app_key,
+                    upsert_charts=_payload_list(item, "upsert_charts", "upsertCharts", "charts", default=upsert_charts or []),
+                    patch_charts=_payload_list(item, "patch_charts", "patchCharts", default=patch_charts or []),
+                    remove_chart_ids=_payload_list(item, "remove_chart_ids", "removeChartIds", default=remove_chart_ids or []),
+                    reorder_chart_ids=_payload_list(item, "reorder_chart_ids", "reorderChartIds", default=reorder_chart_ids or []),
+                    apps=None,
+                ),
+            )
         try:
             request = ChartApplyRequest.model_validate(
                 {
@@ -2623,8 +4176,26 @@ class AiBuilderTools(ToolBase):
         dash_global_config: JSONObject | None = None,
         config: JSONObject | None = None,
         payload: JSONObject | None = None,
+        patch_sections: list[JSONObject] | None = None,
     ) -> JSONObject:
         """执行门户相关逻辑。"""
+        if patch_sections is not None:
+            normalized_args = {
+                "dash_key": dash_key,
+                "publish": publish,
+                "patch_sections": patch_sections,
+            }
+            return _attach_builder_apply_envelope("portal_apply", _publicize_package_fields(_safe_tool_call(
+                lambda: self._facade.portal_patch_sections(
+                    profile=profile,
+                    dash_key=dash_key,
+                    patch_sections=patch_sections,
+                    publish=publish,
+                ),
+                error_code="PORTAL_PATCH_FAILED",
+                normalized_args=normalized_args,
+                suggested_next_call={"tool_name": "portal_get", "arguments": {"profile": profile, "dash_key": dash_key}},
+            )))
         request_payload: dict[str, Any] = dict(payload) if isinstance(payload, dict) else {}
         if dash_key:
             request_payload["dash_key"] = dash_key
@@ -2719,9 +4290,22 @@ class AiBuilderTools(ToolBase):
         *,
         profile: str,
         app_key: str,
+        app_keys: list[str] | None = None,
         expected_package_id: int | None = None,
     ) -> JSONObject:
         """执行应用相关逻辑。"""
+        if app_keys is not None:
+            return self._apply_app_batch(
+                tool_name="app_publish_verify",
+                profile=profile,
+                apps=[{"app_key": item, "expected_package_id": expected_package_id} for item in app_keys],
+                apply_one=lambda _index, item, item_app_key: self.app_publish_verify(
+                    profile=profile,
+                    app_key=item_app_key,
+                    app_keys=None,
+                    expected_package_id=item.get("expected_package_id") or item.get("expectedPackageId") or expected_package_id,
+                ),
+            )
         normalized_args = {"app_key": app_key, "expected_package_id": expected_package_id}
         result = _publicize_package_fields(_safe_tool_call(
             lambda: self._facade.app_publish_verify(profile=profile, app_key=app_key, expected_package_tag_id=expected_package_id),
@@ -2933,7 +4517,12 @@ def _schema_apps_expected_shape() -> JSONObject:
                 "app_name": "员工花名册",
                 "icon": "business-personalcard",
                 "color": "emerald",
-                "add_fields": [{"name": "员工名称", "type": "text", "as_data_title": True}],
+                "form": [
+                    {
+                        "section": "基础信息",
+                        "rows": [[{"name": "员工名称", "type": "text", "data_title": True}]],
+                    }
+                ],
             }
         ],
     }
@@ -2942,7 +4531,7 @@ def _schema_apps_expected_shape() -> JSONObject:
 def _schema_apps_expected_shape_json() -> str:
     return (
         '{"package_id":1001,"apps":[{"client_key":"employee","app_name":"员工花名册",'
-        '"icon":"business-personalcard","color":"emerald","add_fields":[{"name":"员工名称","type":"text","as_data_title":true}]}]}'
+        '"icon":"business-personalcard","color":"emerald","form":[{"section":"基础信息","rows":[[{"name":"员工名称","type":"text","data_title":true}]]}]}]}'
     )
 
 
@@ -3027,6 +4616,163 @@ def _normalize_schema_apps_argument(*, tool_name: str, package_id: int | None, a
     return {"package_id": normalized_package_id, "apps": normalized_items, "warnings": warnings}
 
 
+def _normalize_schema_form_field(field: JSONObject) -> JSONObject:
+    payload = deepcopy(field)
+    if "data_title" in payload and "as_data_title" not in payload and "asDataTitle" not in payload:
+        payload["as_data_title"] = payload.pop("data_title")
+    if "dataTitle" in payload and "as_data_title" not in payload and "asDataTitle" not in payload:
+        payload["as_data_title"] = payload.pop("dataTitle")
+    if "data_cover" in payload and "as_data_cover" not in payload and "asDataCover" not in payload:
+        payload["as_data_cover"] = payload.pop("data_cover")
+    if "dataCover" in payload and "as_data_cover" not in payload and "asDataCover" not in payload:
+        payload["as_data_cover"] = payload.pop("dataCover")
+    return payload
+
+
+def _schema_form_entry_name(entry: object) -> str:
+    if isinstance(entry, dict):
+        for key in ("name", "title", "label", "field_name", "fieldName"):
+            if entry.get(key) is not None:
+                return str(entry.get(key) or "").strip()
+        return ""
+    if isinstance(entry, (str, int)):
+        return str(entry).strip()
+    return ""
+
+
+def _schema_form_failure(*, tool_name: str, path: str, message: str, fix_hint: str) -> JSONObject:
+    return _config_failure(
+        tool_name=tool_name,
+        error_code="FORM_SHAPE_INVALID",
+        message=message,
+        fix_hint=fix_hint,
+        details={
+            "path": path,
+            "expected_shape": {
+                "form": [
+                    {
+                        "section": "基础信息",
+                        "rows": [
+                            [
+                                {"name": "标题", "type": "text", "data_title": True},
+                                {"name": "状态", "type": "single_select", "options": ["待处理", "处理中", "已完成"]},
+                            ]
+                        ],
+                    }
+                ]
+            },
+        },
+    )
+
+
+def _compile_schema_form_payload(*, tool_name: str, form: object, path: str = "form") -> JSONObject:
+    if form is None:
+        return {"add_fields": [], "layout_sections": []}
+    if not isinstance(form, list) or not form:
+        return {
+            "failure": _schema_form_failure(
+                tool_name=tool_name,
+                path=path,
+                message=f"{path} must be a non-empty list of form sections.",
+                fix_hint='Use form=[{"section":"基础信息","rows":[[{"name":"标题","type":"text","data_title":true}]]}].',
+            )
+        }
+
+    add_fields: list[JSONObject] = []
+    layout_sections: list[JSONObject] = []
+    for section_index, section in enumerate(form):
+        section_path = f"{path}[{section_index}]"
+        if not isinstance(section, dict):
+            return {
+                "failure": _schema_form_failure(
+                    tool_name=tool_name,
+                    path=section_path,
+                    message=f"{section_path} must be an object.",
+                    fix_hint="Each form section must include section and rows.",
+                )
+            }
+        section_title = str(section.get("section") or section.get("title") or section.get("name") or "").strip()
+        rows = section.get("rows")
+        if not section_title:
+            return {
+                "failure": _schema_form_failure(
+                    tool_name=tool_name,
+                    path=f"{section_path}.section",
+                    message=f"{section_path}.section is required.",
+                    fix_hint='Set a business section title such as "基础信息" or "生产信息".',
+                )
+            }
+        if not isinstance(rows, list) or not rows:
+            return {
+                "failure": _schema_form_failure(
+                    tool_name=tool_name,
+                    path=f"{section_path}.rows",
+                    message=f"{section_path}.rows must be a non-empty list.",
+                    fix_hint="Use rows as a list of field rows; each row is a list of field objects.",
+                )
+            }
+        layout_rows: list[list[str]] = []
+        for row_index, row in enumerate(rows):
+            row_path = f"{section_path}.rows[{row_index}]"
+            if isinstance(row, dict):
+                row_fields = row.get("fields")
+            else:
+                row_fields = row
+            if not isinstance(row_fields, list) or not row_fields:
+                return {
+                    "failure": _schema_form_failure(
+                        tool_name=tool_name,
+                        path=row_path,
+                        message=f"{row_path} must be a non-empty field list.",
+                        fix_hint='Use rows like [[{"name":"字段A","type":"text"},{"name":"字段B","type":"number"}]].',
+                    )
+                }
+            layout_row: list[str] = []
+            for field_index, field in enumerate(row_fields):
+                field_path = f"{row_path}[{field_index}]"
+                field_name = _schema_form_entry_name(field)
+                if not field_name:
+                    return {
+                        "failure": _schema_form_failure(
+                            tool_name=tool_name,
+                            path=field_path,
+                            message=f"{field_path} must include a field name.",
+                            fix_hint='Each new field object must include name, for example {"name":"工单编号","type":"text"}.',
+                        )
+                    }
+                layout_row.append(field_name)
+                if isinstance(field, dict):
+                    add_fields.append(_normalize_schema_form_field(field))
+            layout_rows.append(layout_row)
+        layout_sections.append({"title": section_title, "rows": layout_rows})
+    return {"add_fields": add_fields, "layout_sections": layout_sections}
+
+
+def _apply_schema_form_to_payload(*, tool_name: str, payload: JSONObject, path: str) -> JSONObject:
+    form = payload.get("form")
+    if form is None:
+        return {"payload": payload, "layout_sections": []}
+    existing_add_fields = payload.get("add_fields") or payload.get("addFields")
+    if isinstance(existing_add_fields, list) and existing_add_fields:
+        return {
+            "failure": _config_failure(
+                tool_name=tool_name,
+                error_code="FORM_WITH_ADD_FIELDS_CONFLICT",
+                message=f"{path} cannot use form and add_fields together.",
+                fix_hint="Use form as the single schema creation shape: put fields under form[].rows[][].",
+                details={"path": path, "conflicting_keys": ["form", "add_fields"]},
+            )
+        }
+    compiled = _compile_schema_form_payload(tool_name=tool_name, form=form, path=f"{path}.form")
+    if isinstance(compiled.get("failure"), dict):
+        return {"failure": compiled["failure"]}
+    normalized = deepcopy(payload)
+    normalized.pop("form", None)
+    normalized["add_fields"] = compiled.get("add_fields") or []
+    normalized["_inline_form_layout_sections"] = compiled.get("layout_sections") or []
+    return {"payload": normalized, "layout_sections": compiled.get("layout_sections") or []}
+
+
 def _multi_app_item_app_name(item: JSONObject) -> str:
     return str(item.get("app_name") or item.get("appName") or item.get("appTitle") or item.get("app_title") or item.get("title") or "").strip()
 
@@ -3048,7 +4794,7 @@ def _field_type_for_static_validation(field: JSONObject) -> str:
 
 
 def _is_data_title_field(field: JSONObject) -> bool:
-    return bool(field.get("as_data_title") or field.get("asDataTitle"))
+    return bool(field.get("as_data_title") or field.get("asDataTitle") or field.get("data_title") or field.get("dataTitle"))
 
 
 def _collect_multi_app_target_refs(value: object, *, path: str) -> list[JSONObject]:
@@ -3075,7 +4821,6 @@ def _multi_app_static_validation_failure(
     *,
     tool_name: str,
     apps: list[JSONObject],
-    create_if_missing: bool,
 ) -> JSONObject | None:
     issues: list[JSONObject] = []
     client_key_indexes: dict[str, int] = {}
@@ -3138,17 +4883,6 @@ def _multi_app_static_validation_failure(
                 }
             )
             continue
-        if new_app_item and not create_if_missing:
-            issues.append(
-                {
-                    "index": index,
-                    "row_number": index + 1,
-                    "path": f"apps[{index}]",
-                    "error_code": "CREATE_IF_MISSING_REQUIRED",
-                    "message": "new multi-app items require create_if_missing=true",
-                    "fix_hint": "Set create_if_missing=true, or pass app_key for an existing app.",
-                }
-            )
 
         add_fields = _multi_app_list_value(item, "add_fields", "addFields")
         if new_app_item:
@@ -3350,6 +5084,86 @@ def _compiled_multi_app_deferred_add_fields(compiled_item: JSONObject, existing_
     ]
 
 
+def _multi_app_child_diagnostics(result: JSONObject) -> JSONObject:
+    diagnostics: JSONObject = {}
+    for key in (
+        "backend_code",
+        "http_status",
+        "request_id",
+        "details",
+        "suggested_next_call",
+        "warnings",
+        "publish_result",
+        "duration_breakdown_ms",
+    ):
+        value = result.get(key)
+        if value is None:
+            continue
+        if isinstance(value, (dict, list)) and not value:
+            continue
+        diagnostics[key] = deepcopy(value)
+    return diagnostics
+
+
+def _multi_app_field_type(field: JSONObject) -> str:
+    raw_type = str(field.get("type") or field.get("field_type") or field.get("fieldType") or "").strip()
+    if raw_type:
+        normalized = FIELD_TYPE_ALIASES.get(raw_type.lower())
+        return normalized.value if normalized is not None else raw_type
+    raw_type_id = field.get("type_id") or field.get("typeId") or field.get("field_type_id") or field.get("fieldTypeId")
+    try:
+        normalized_by_id = FIELD_TYPE_ID_ALIASES.get(int(raw_type_id))
+    except (TypeError, ValueError):
+        normalized_by_id = None
+    return normalized_by_id.value if normalized_by_id is not None else ""
+
+
+def _multi_app_deferred_relation_retryable(result: JSONObject, deferred_add_fields: list[JSONObject]) -> bool:
+    if not deferred_add_fields:
+        return False
+    if not any(_multi_app_field_type(field) == PublicFieldType.relation.value for field in deferred_add_fields if isinstance(field, dict)):
+        return False
+    if result.get("status") in {"success", "partial_success"}:
+        return False
+    if result.get("error_code") != "SCHEMA_APPLY_FAILED":
+        return False
+    if _schema_apply_result_has_write(result):
+        return False
+    return backend_code_value_int(_result_backend_code(result)) == 400
+
+
+def _result_backend_code(result: JSONObject) -> Any:
+    if result.get("backend_code") is not None:
+        return result.get("backend_code")
+    details = result.get("details")
+    if isinstance(details, dict):
+        transport = details.get("transport_error")
+        if isinstance(transport, dict):
+            return transport.get("backend_code")
+    return None
+
+
+def _multi_app_relation_target_app_keys(fields: list[JSONObject]) -> list[str]:
+    app_keys: list[str] = []
+
+    def visit(value: Any) -> None:
+        if isinstance(value, list):
+            for item in value:
+                visit(item)
+            return
+        if not isinstance(value, dict):
+            return
+        target_app_key = str(value.get("target_app_key") or value.get("targetAppKey") or "").strip()
+        if target_app_key and target_app_key not in app_keys:
+            app_keys.append(target_app_key)
+        for child in value.values():
+            if isinstance(child, (dict, list)):
+                visit(child)
+
+    visit(fields)
+    return app_keys
+
+
 def _multi_app_list_value(item: JSONObject, *keys: str) -> list[JSONObject]:
     for key in keys:
         value = item.get(key)
@@ -3527,7 +5341,6 @@ def _reserved_system_field_name_failure(
     icon: str | None = None,
     color: str | None = None,
     visibility: JSONObject | None = None,
-    create_if_missing: bool = False,
     publish: bool | None = None,
     add_fields: list[JSONObject] | None = None,
     update_fields: list[JSONObject] | None = None,
@@ -3547,7 +5360,6 @@ def _reserved_system_field_name_failure(
             "icon": icon or "",
             "color": color or "",
             "visibility": visibility,
-            "create_if_missing": create_if_missing,
             "add_fields": suggested_add_fields,
             "update_fields": update_fields or [],
             "remove_fields": remove_fields or [],
@@ -3576,7 +5388,6 @@ def _reserved_system_field_name_failure_for_apps(
     profile: str,
     package_id: int | None,
     visibility: JSONObject | None,
-    create_if_missing: bool,
     publish: bool,
     apps: list[JSONObject],
 ) -> JSONObject | None:
@@ -3592,7 +5403,6 @@ def _reserved_system_field_name_failure_for_apps(
             icon=str(item.get("icon") or ""),
             color=str(item.get("color") or ""),
             visibility=item.get("visibility") if isinstance(item.get("visibility"), dict) else visibility,
-            create_if_missing=create_if_missing,
             publish=publish,
             add_fields=list(item.get("add_fields") or item.get("addFields") or []),
             update_fields=list(item.get("update_fields") or item.get("updateFields") or []),
@@ -3610,7 +5420,6 @@ def _reserved_system_field_name_failure_for_apps(
                     "profile": profile,
                     "package_id": package_id,
                     "visibility": visibility,
-                    "create_if_missing": create_if_missing,
                     "publish": publish,
                     "apps": fixed_apps,
                 }
@@ -3677,6 +5486,23 @@ def _reserved_system_view_name_failure(
     return None
 
 
+def _view_payload_has_action_buttons(
+    *,
+    upsert_views: list[JSONObject] | None = None,
+    patch_views: list[JSONObject] | None = None,
+) -> bool:
+    for item in upsert_views or []:
+        if isinstance(item, dict) and any(key in item for key in ("action_buttons", "actionButtons")):
+            return True
+    for item in patch_views or []:
+        if not isinstance(item, dict):
+            continue
+        raw_set = item.get("set")
+        if isinstance(raw_set, dict) and any(key in raw_set for key in ("action_buttons", "actionButtons")):
+            return True
+    return False
+
+
 def _config_failure(
     *,
     tool_name: str,
@@ -3768,12 +5594,13 @@ def _safe_tool_call(
     normalized_args: JSONObject,
     suggested_next_call: JSONObject | None,
 ) -> JSONObject:
+    started_at = time.perf_counter()
     try:
-        return call()
+        result = call()
     except (QingflowApiError, RuntimeError) as error:
         api_error = _coerce_api_error(error)
         public_http_status = None if api_error.http_status == 404 else api_error.http_status
-        return {
+        result = {
             "status": "failed",
             "error_code": error_code,
             "recoverable": True,
@@ -3795,6 +5622,46 @@ def _safe_tool_call(
             "noop": False,
             "verification": {},
         }
+    except ValueError as error:
+        public_error_code, public_message = _public_value_error(error, fallback_error_code=error_code)
+        result = {
+            "status": "failed",
+            "error_code": public_error_code,
+            "recoverable": True,
+            "message": public_message,
+            "normalized_args": normalized_args,
+            "missing_fields": [],
+            "allowed_values": {},
+            "details": {
+                "validation_error": {
+                    "message": str(error),
+                    "fallback_error_code": error_code,
+                }
+            },
+            "suggested_next_call": suggested_next_call,
+            "write_executed": False,
+            "safe_to_retry": True,
+            "noop": False,
+            "verification": {},
+        }
+    if isinstance(result, dict):
+        _merge_duration_breakdown(result, tool_call_ms=_elapsed_ms(started_at))
+    return result
+
+
+def _public_value_error(error: ValueError, *, fallback_error_code: str) -> tuple[str, str]:
+    message = str(error).strip() or fallback_error_code
+    prefix, separator, rest = message.partition(":")
+    candidate = prefix.strip()
+    if separator and _looks_like_public_error_code(candidate):
+        return candidate, rest.strip() or message
+    return fallback_error_code, message
+
+
+def _looks_like_public_error_code(value: str) -> bool:
+    if not value or len(value) > 80 or not any(ch.isalpha() for ch in value):
+        return False
+    return all(ch.isupper() or ch.isdigit() or ch == "_" for ch in value)
 
 
 def _publicize_package_fields(value):
@@ -3874,6 +5741,8 @@ def _builder_apply_json_paths() -> JSONObject:
         "warnings": "$.warnings",
         "verification": "$.verification",
         "details": "$.details",
+        "duration_breakdown_ms": "$.duration_breakdown_ms",
+        "total_ms": "$.duration_breakdown_ms.total_ms",
         "write_executed": "$.write_executed",
         "write_may_have_succeeded": "$.write_may_have_succeeded",
         "safe_to_retry": "$.safe_to_retry",
@@ -3910,6 +5779,8 @@ def _builder_apply_summary(payload: JSONObject, resources: list[JSONObject]) ->
         and str(item.get("operation") or "") in {"updated", "layout_updated", "workflow_updated", "verified", "published"}
     )
     published_value = payload.get("published")
+    if published_value is None:
+        published_value = _builder_batch_published_value(payload)
     if published_value is None:
         publish_requested = payload.get("publish_requested")
         published_value = bool(publish_requested) and status in {"success", "partial_success"}
@@ -3939,6 +5810,24 @@ def _builder_apply_summary(payload: JSONObject, resources: list[JSONObject]) ->
     return summary
 
 
+def _builder_batch_published_value(payload: JSONObject) -> bool | None:
+    apps = payload.get("apps")
+    if not isinstance(apps, list) or not apps:
+        return None
+    values: list[bool] = []
+    for item in apps:
+        if not isinstance(item, dict):
+            continue
+        result = item.get("result") if isinstance(item.get("result"), dict) else {}
+        if "published" in result:
+            values.append(bool(result.get("published")))
+        elif "published" in item:
+            values.append(bool(item.get("published")))
+    if not values:
+        return None
+    return all(values)
+
+
 def _builder_verification_truthy(value: object) -> bool:
     if value is None:
         return True
@@ -3956,6 +5845,8 @@ def _builder_apply_resources(tool_name: str, payload: JSONObject) -> list[JSONOb
         resources = _builder_package_resources(payload)
     elif tool_name == "app_schema_apply":
         resources = _builder_schema_resources(payload)
+    elif isinstance(payload.get("apps"), list) and _builder_apply_tool_is_app_scoped(tool_name):
+        resources = _builder_batch_app_resources(tool_name, payload)
     elif tool_name == "app_layout_apply":
         resources = [_builder_app_resource(payload, operation="layout_updated")]
     elif tool_name == "app_flow_apply":
@@ -3983,6 +5874,38 @@ def _builder_apply_resources(tool_name: str, payload: JSONObject) -> list[JSONOb
     return resources
 
 
+def _builder_batch_app_resources(tool_name: str, payload: JSONObject) -> list[JSONObject]:
+    resources: list[JSONObject] = []
+    operation_by_tool = {
+        "app_schema_apply": "updated",
+        "app_layout_apply": "layout_updated",
+        "app_flow_apply": "workflow_updated",
+        "app_views_apply": "updated",
+        "app_custom_buttons_apply": "updated",
+        "app_associated_resources_apply": "updated",
+        "app_charts_apply": "updated",
+        "app_publish_verify": "verified",
+    }
+    operation = operation_by_tool.get(tool_name, "updated")
+    for item in payload.get("apps") or []:
+        if not isinstance(item, dict):
+            continue
+        result = item.get("result") if isinstance(item.get("result"), dict) else {}
+        nested_resources = result.get("resources") if isinstance(result, dict) else None
+        if isinstance(nested_resources, list) and nested_resources:
+            resources.extend(resource for resource in nested_resources if isinstance(resource, dict))
+            continue
+        app_payload: JSONObject = {
+            **(result if isinstance(result, dict) else {}),
+            "app_key": item.get("app_key") or (result.get("app_key") if isinstance(result, dict) else None),
+            "status": item.get("status") or (result.get("status") if isinstance(result, dict) else None),
+            "error_code": item.get("error_code") or (result.get("error_code") if isinstance(result, dict) else None),
+            "message": item.get("message") or (result.get("message") if isinstance(result, dict) else None),
+        }
+        resources.append(_builder_app_resource(app_payload, operation=operation))
+    return resources
+
+
 def _builder_apply_tool_is_app_scoped(tool_name: str) -> bool:
     return tool_name in {
         "app_schema_apply",
@@ -4290,6 +6213,33 @@ def _builder_field_resources(field_diff: object, *, parent: JSONObject | None) -
 
 
 def _builder_view_resources(payload: JSONObject) -> list[JSONObject]:
+    if isinstance(payload.get("views"), list):
+        resources: list[JSONObject] = []
+        for item in payload.get("views") or []:
+            if not isinstance(item, dict):
+                continue
+            result = item.get("result") if isinstance(item.get("result"), dict) else {}
+            parent = _builder_app_parent({"app_key": item.get("app_key") or result.get("app_key")})
+            operation = str(item.get("operation") or item.get("requested_operation") or "updated")
+            if operation == "upsert":
+                operation = "updated"
+            resources.append(
+                _builder_resource(
+                    resource_type="view",
+                    operation=operation,
+                    status=str(item.get("status") or result.get("status") or "success"),
+                    key=item.get("view_key") or item.get("viewKey"),
+                    name=item.get("name") or item.get("view_name") or item.get("viewName"),
+                    ids={
+                        **({"view_key": item.get("view_key") or item.get("viewKey")} if item.get("view_key") or item.get("viewKey") else {}),
+                        **({"app_key": item.get("app_key")} if item.get("app_key") else {}),
+                    },
+                    parent=parent,
+                    error_code=item.get("error_code") or result.get("error_code"),
+                    message=item.get("message") or result.get("message"),
+                )
+            )
+        return resources
     diff = payload.get("views_diff") if isinstance(payload.get("views_diff"), dict) else {}
     verification_by_name = _builder_view_verification_by_name(payload)
     parent = _builder_app_parent(payload)
@@ -4331,6 +6281,15 @@ def _builder_view_resources(payload: JSONObject) -> list[JSONObject]:
                 message=message,
             )
         )
+    details = payload.get("details") if isinstance(payload.get("details"), dict) else {}
+    action_buttons_result = details.get("action_buttons_result") if isinstance(details, dict) else None
+    if isinstance(action_buttons_result, dict):
+        nested_payload = {
+            **action_buttons_result,
+            "app_key": payload.get("app_key"),
+            "app_name": payload.get("app_name"),
+        }
+        resources.extend(_builder_button_resources(nested_payload))
     return resources
 
 
@@ -4821,7 +6780,6 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
         "allowed_keys": [
             "package_id",
             "package_name",
-            "create_if_missing",
             "icon",
             "color",
             "icon_name",
@@ -4834,7 +6792,6 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
         "aliases": {
             "packageId": "package_id",
             "packageName": "package_name",
-            "createIfMissing": "create_if_missing",
             "iconName": "icon",
             "iconColor": "color",
             "icon_config.name": "icon",
@@ -4851,6 +6808,7 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
         },
         "execution_notes": [
             "create or update package metadata, visibility, grouping, and ordering in one call",
+            "create mode: package_name without package_id creates a package",
             "creating a package requires explicit icon + color; icon=template is blocked because it is too generic",
             "agent-facing primary icon shape is icon + color; icon_name/icon_color, icon_config, and icon={name,color} are compatibility aliases that normalize to icon/color",
             "updating a package preserves existing icon/color when omitted; explicit icon/color values are still validated",
@@ -4859,6 +6817,7 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "package_id maps internally to backend tagId; do not use tag_id in public calls",
             "items is a full package layout tree; omitting existing app/portal items is blocked unless allow_detach=true",
             "item shapes: {type:'app', app_key}, {type:'portal', dash_key}, or {type:'group', group_id?, name, items:[...]}",
+            "allow_detach=true with flat app/portal items and no groups is treated as an explicit full replacement and skips current layout read plus final package readback",
             "layout apply calls backend package ordering (MoveGroupAuth), so it requires package edit_app permission even when items=[] only clears/deletes existing groups",
             *_VISIBILITY_EXECUTION_NOTES,
         ],
@@ -4878,7 +6837,6 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
         "create_example": {
             "profile": "default",
             "package_name": "项目管理",
-            "create_if_missing": True,
             "icon": "briefcase",
             "color": "azure",
             "visibility": deepcopy(_VISIBILITY_WORKSPACE_EXAMPLE),
@@ -5097,6 +7055,7 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "remove_buttons supports button_id or exact unique button_text",
             "after a remove_buttons DELETE is sent, the tool verifies deletion by single button_id readback; removed[] returns delete_executed, readback_status, and safe_to_retry_delete=false",
             "if a removed button returns readback_status=unavailable or still_exists, treat the result as readback pending and do not blindly repeat the delete",
+            "pure create/update with returned button ids and no view_configs/remove skips the final custom-button inventory read; response details.final_readback_skipped=true",
             "all operations share one edit context and publish after at least one write succeeds; there is no draft-only mode for this tool",
             "background_color and text_color cannot both be white",
         ],
@@ -5190,6 +7149,7 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "upsert_resources[].match_mappings[].target_field",
             "upsert_resources[].match_mappings[].source_field",
             "upsert_resources[].match_mappings[].value",
+            "upsert_resources[].match_mappings[].values",
             "upsert_resources[].match_mappings[].operator",
             "upsert_resources[].match_rules",
             "patch_resources[].associated_item_id",
@@ -5224,6 +7184,16 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
         "allowed_values": {
             "upsert_resources[].graph_type": ["chart", "view"],
             "upsert_resources[].report_source": ["app", "dataset"],
+            "upsert_resources[].match_mappings[].operator": [
+                "eq",
+                "neq",
+                "in",
+                "contains",
+                "gte",
+                "lte",
+                "is_empty",
+                "not_empty",
+            ],
             "view_configs[].limit_type": ["all", "select"],
         },
         "execution_notes": [
@@ -5236,12 +7206,15 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "before creating an associated resource, read app_get.associated_resources and reuse an existing item with patch_resources when target_app_key + view_key/chart_key already matches; repeated upsert_resources without associated_item_id can create duplicate associated items",
             "graph_type=view uses view_key and internally compiles to the Qingflow view source; graph_type=chart uses chart_key and defaults to report_source=app",
             "report_source=app maps to BI_QINGFLOW; report_source=dataset maps to BI_DATASET for associating an existing dataset report; do not pass raw backend sourceType",
-            "use match_mappings for associated view/report filtering; dynamic conditions use source_field and static conditions use value",
+            "use match_mappings for associated view/report filtering; dynamic conditions use source_field and static conditions use value/values",
             "match_mappings.source_field accepts source schema fields plus system fields 数据ID(-17) and 编号(0); match_mappings compiles to backend matchRules",
+            "match_mappings uses the same public operator semantics as view/chart filters: eq, neq, in, contains, gte, lte, is_empty, not_empty; field_name/field are aliases of target_field",
+            "static multi-value conditions use values; is_empty/not_empty conditions do not need source_field/value/values",
             "do not write raw match_rules unless preserving a legacy backend config; match_mappings and match_rules are mutually exclusive",
             "client_key only lets a view_config reference a resource created earlier in the same apply call through associated_item_refs; it is not persisted and cannot deduplicate later apply calls",
             "remove_associated_item_ids sends DELETE and verifies deletion with one associated-resource pool readback because the backend has no confirmed single-item GET; removed[] returns delete_executed, readback_status, and safe_to_retry_delete=false",
             "if an associated resource delete returns readback_status=unavailable or still_exists, treat the result as readback pending and do not blindly repeat the delete",
+            "pure create/update with returned associated_item_id values and no view_configs/remove/reorder skips the final associated-resource pool read; response details.final_readback_skipped=true",
             "this tool publishes after at least one write succeeds; there is no draft-only mode",
             "visible=false hides the associated-resource area without clearing previous selected ids; visible=true with limit_type=all shows the whole app-level pool",
         ],
@@ -5276,7 +7249,7 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
         },
     },
     "app_schema_plan": {
-        "allowed_keys": ["app_key", "package_id", "app_name", "icon", "color", "visibility", "create_if_missing", "add_fields", "update_fields", "remove_fields"],
+        "allowed_keys": ["app_key", "package_id", "app_name", "icon", "color", "visibility", "add_fields", "update_fields", "remove_fields"],
         "aliases": {
             "app_title": "app_name",
             "title": "app_name",
@@ -5301,6 +7274,10 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "field.customBtnTextStatus": "field.custom_button_text_enabled",
             "field.customBtnText": "field.custom_button_text",
             "field.subfieldUpdates": "field.subfield_updates",
+            "field.data_title": "field.as_data_title",
+            "field.dataTitle": "field.as_data_title",
+            "field.data_cover": "field.as_data_cover",
+            "field.dataCover": "field.as_data_cover",
             "field.asDataTitle": "field.as_data_title",
             "field.asDataCover": "field.as_data_cover",
         },
@@ -5327,8 +7304,7 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "icon": "briefcase",
             "color": "emerald",
             "visibility": deepcopy(_VISIBILITY_WORKSPACE_EXAMPLE),
-            "create_if_missing": True,
-            "add_fields": [{"name": "项目名称", "type": "text", "as_data_title": True}],
+            "add_fields": [{"name": "项目名称", "type": "text", "data_title": True}],
             "update_fields": [],
             "remove_fields": [],
         },
@@ -5361,8 +7337,8 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "icon_color",
             "icon_config",
             "visibility",
-            "create_if_missing",
             "publish",
+            "form",
             "add_fields",
             "update_fields",
             "remove_fields",
@@ -5376,6 +7352,9 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "apps[].icon_color",
             "apps[].icon_config",
             "apps[].visibility",
+            "apps[].form",
+            "apps[].form[].section",
+            "apps[].form[].rows",
             "apps[].add_fields",
             "apps[].update_fields",
             "apps[].remove_fields",
@@ -5420,6 +7399,10 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "field.customBtnTextStatus": "field.custom_button_text_enabled",
             "field.customBtnText": "field.custom_button_text",
             "field.subfieldUpdates": "field.subfield_updates",
+            "field.data_title": "field.as_data_title",
+            "field.dataTitle": "field.as_data_title",
+            "field.data_cover": "field.as_data_cover",
+            "field.dataCover": "field.as_data_cover",
             "field.asDataTitle": "field.as_data_title",
             "field.asDataCover": "field.as_data_cover",
         },
@@ -5436,13 +7419,17 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
         "execution_notes": [
             "use exactly one resource mode",
             "edit mode: app_key, optional app_name to rename the existing app",
-            "create mode: package_id + app_name + create_if_missing=true",
+            "create mode: package_id + app_name",
+            "create mode submits a create request directly after basic package add_app permission check; it does not scan app_name duplicates or reuse an existing app by name",
             "create mode follows backend CreateAppBean: package add_app permission is checked on the target package; package edit_app is not required for the create precheck",
-            "multi-app mode: pass package_id + create_if_missing + apps[]; do not mix apps with top-level app_key/app_name/add_fields/update_fields/remove_fields",
+            "multi-app mode: pass package_id + apps[]; items with app_name and no app_key are created, items with app_key update existing apps",
             "CLI --apps-file primary shape is {package_id, apps:[...]}; raw app arrays and singleton wrapper arrays are compatibility paths, not recommended examples",
-            "multi-app mode preflights static errors before writing: duplicate client_key/app_name, missing data title on new apps, create_if_missing omissions, and unresolved target_app_ref/target_app",
+            "create app schemas with form: form[].section names form sections; form[].rows[][] contains field objects; builder splits form into field creation plus form layout apply",
+            "single-app CLI primary shape is --form-file; multi-app primary shape is apps[].form inside --apps-file",
+            "multi-app mode validates static payload errors before writing: duplicate client_key/app_name, missing data title on new apps, and unresolved target_app_ref/target_app",
             "multi-app relation fields may use target_app_ref to point at another apps[].client_key; the tool creates/resolves app shells first and compiles it to target_app_key",
             "multi-app relation fields may also use target_app with another apps[].app_name; prefer target_app_ref/client_key when names may collide",
+            "multi-app schema writes run in dependency waves: apps without same-batch relation dependencies write first, then dependent apps write in parallel by layer; response.parallelism includes schema_wave_count/schema_wave_sizes",
             "multi-app mode is not transactional; read created_app_keys and apps[].status before retrying, and retry only failed app items",
             "create mode defaults new app visibility to workspace/not when visibility is omitted; edit mode preserves current visibility when omitted",
             "create mode requires explicit icon + color; icon=template is blocked because it is too generic",
@@ -5455,8 +7442,8 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "do not add form fields named 数据ID, 编号, 申请人, 申请时间, 创建人, 创建时间, 提交人, 提交时间, 更新时间, 更新人, 当前流程状态, 当前处理人, 当前处理节点, or 流程标题; these are Qingflow built-in system fields, not fields to create",
             *_VISIBILITY_EXECUTION_NOTES,
             "update_fields is the field-level partial update path; it reads current form schema and preserves untouched field config",
-            "multiple relation fields are backend-risky; read verification.relation_field_limit_verified and warnings before declaring the schema stable",
-            "backend 49614 is normalized to MULTIPLE_RELATION_FIELDS_UNSUPPORTED with a workaround message",
+            "an app may contain multiple relation fields; do not downgrade secondary relations to text just because more than one relation exists",
+            "backend relation errors are returned as normal schema apply failures with backend_code/details; they are not normalized into a one-relation modeling fallback",
             "relation_mode=multiple maps to referenceConfig.optionalDataNum=0",
             "relation fields now require both display_field and visible_fields in MCP/CLI payloads",
             "if relation target metadata lookup is blocked by 40161/40002/40027, explicit display_field.name and visible_fields[].name let builder degrade verification and still continue schema write",
@@ -5481,11 +7468,17 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "icon": "briefcase",
             "color": "emerald",
             "visibility": deepcopy(_VISIBILITY_WORKSPACE_EXAMPLE),
-            "create_if_missing": True,
             "publish": True,
-            "add_fields": [
-                {"name": "项目名称", "type": "text", "as_data_title": True},
-                {"name": "项目封面", "type": "attachment", "as_data_cover": True},
+            "form": [
+                {
+                    "section": "基础信息",
+                    "rows": [
+                        [
+                            {"name": "项目名称", "type": "text", "data_title": True},
+                            {"name": "项目封面", "type": "attachment", "data_cover": True},
+                        ]
+                    ],
+                }
             ],
             "update_fields": [],
             "remove_fields": [],
@@ -5493,7 +7486,6 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
         "multi_app_example": {
             "profile": "default",
             "package_id": 1001,
-            "create_if_missing": True,
             "publish": True,
             "apps": [
                 {
@@ -5501,9 +7493,16 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
                     "app_name": "员工花名册",
                     "icon": "business-personalcard",
                     "color": "emerald",
-                    "add_fields": [
-                        {"name": "员工名称", "type": "text", "as_data_title": True},
-                        {"name": "员工照片", "type": "attachment", "as_data_cover": True},
+                    "form": [
+                        {
+                            "section": "基础信息",
+                            "rows": [
+                                [
+                                    {"name": "员工名称", "type": "text", "data_title": True},
+                                    {"name": "员工照片", "type": "attachment", "data_cover": True},
+                                ]
+                            ],
+                        }
                     ],
                 },
                 {
@@ -5511,15 +7510,22 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
                     "app_name": "工时表",
                     "icon": "clock",
                     "color": "blue",
-                    "add_fields": [
-                        {"name": "工时标题", "type": "text", "as_data_title": True},
+                    "form": [
                         {
-                            "name": "关联员工",
-                            "type": "relation",
-                            "target_app_ref": "employee",
-                            "display_field": {"name": "员工名称"},
-                            "visible_fields": [{"name": "员工名称"}],
-                        },
+                            "section": "基础信息",
+                            "rows": [
+                                [{"name": "工时标题", "type": "text", "data_title": True}],
+                                [
+                                    {
+                                        "name": "关联员工",
+                                        "type": "relation",
+                                        "target_app_ref": "employee",
+                                        "display_field": {"name": "员工名称"},
+                                        "visible_fields": [{"name": "员工名称"}],
+                                    }
+                                ],
+                            ],
+                        }
                     ],
                 },
             ],
@@ -5703,56 +7709,88 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "sections": [{"type": "paragraph", "paragraph_id": "basic", "title": "基础信息", "rows": [["项目名称", "项目负责人", "项目阶段", "优先级"]]}],
         },
     },
-    "app_flow_get_schema": {
-        "allowed_keys": ["schema_version"],
-        "aliases": {"schemaVersion": "schema_version"},
-        "allowed_values": {},
-        "execution_notes": [
-            "returns WorkflowSpec JSON Schema from /workflow/spec/schema",
-            "call this before authoring a new spec or validating spec shape",
-            "worksheet-level approval deduplication toggles (legacy global settings) are not yet part of WorkflowSpec",
-        ],
-        "minimal_example": {
-            "profile": "default",
-            "schema_version": "vnext-2026-06",
+    "app_flow_plan": {
+        "allowed_keys": ["app_key", "mode", "nodes", "transitions", "preset"],
+        "aliases": {
+            "overwrite": "replace",
+            "base_preset": "preset",
+            "default_approval": "basic_approval",
+            "node.role_names": "node.assignees.role_names",
+            "node.role_ids": "node.assignees.role_ids",
+            "node.member_names": "node.assignees.member_names",
+            "node.member_emails": "node.assignees.member_emails",
+            "node.member_uids": "node.assignees.member_uids",
+            "node.editable_fields": "node.permissions.editable_fields",
+            "default_approval": "basic_approval",
         },
-    },
-    "app_flow_get": {
-        "allowed_keys": ["app_key", "version_id"],
-        "aliases": {"versionId": "version_id"},
-        "allowed_values": {},
+        "allowed_values": {
+            "mode": ["replace"],
+            "preset": [member.value for member in FlowPreset],
+            "node.type": PUBLIC_STABLE_FLOW_NODE_TYPES,
+        },
+        "dependency_hints": [
+            "approval-style workflows require an explicit business status select field before app_flow_apply, such as 状态 / 处理状态 / 审批状态 / 工单状态",
+            "approve/fill/copy nodes require at least one assignee",
+        ],
         "execution_notes": [
-            "returns current WorkflowSpecDTO for one app via GET /workflow/spec",
-            "use GET-first before patching and app_flow_apply",
+            "app_flow_plan is private compatibility plumbing, not an agent-facing workflow path; use app_flow_get/app_flow_get_schema plus app_flow_apply spec or patch_nodes",
+            "do not create platform system workflow fields such as 当前流程状态 / 当前处理人 / 当前处理节点 / 流程标题; use an explicit business status field instead",
         ],
         "minimal_example": {
             "profile": "default",
             "app_key": "APP_KEY",
+            "mode": "replace",
+            "preset": "basic_approval",
+            "nodes": [
+                {
+                    "id": "approve_1",
+                    "type": "approve",
+                    "name": "部门审批",
+                    "assignees": {"role_names": ["项目经理"]},
+                    "permissions": {"editable_fields": ["状态", "审批意见"]},
+                }
+            ],
+            "transitions": [],
         },
     },
     "app_flow_apply": {
-        "allowed_keys": ["app_key", "publish", "spec", "idempotency_key", "schema_version"],
+        "allowed_keys": [
+            "app_key",
+            "publish",
+            "spec",
+            "patch_nodes",
+            "idempotency_key",
+            "schema_version",
+        ],
         "aliases": {
-            "schemaVersion": "schema_version",
+            "patchNodes": "patch_nodes",
             "idempotencyKey": "idempotency_key",
+            "schemaVersion": "schema_version",
         },
         "allowed_values": {},
         "dependency_hints": [
-            "spec must be a complete WorkflowSpecDTO object (replace-only apply)",
+            "approval-style workflows require an explicit business status select field before app_flow_apply, such as 状态 / 处理状态 / 审批状态 / 工单状态",
+            "WorkflowSpec nodes should declare sync=true for routing nodes and explicit assignees for approval/filling/cc nodes",
         ],
         "execution_notes": [
-            "posts to /workflow/spec:apply with appKey, idempotencyKey, schemaVersion, and spec",
-            "verification uses appliedSpec, diffSummary, and semanticLint from the apply response",
-            "publish=false keeps changes in draft when supported by the backend",
+            "preferred full workflow path is app_flow_get_schema/app_flow_get -> app_flow_apply with spec",
+            "use patch_nodes for targeted existing-node edits; each item uses id plus set/unset",
+            "public workflow writes use only spec or patch_nodes",
+            "do not mix spec and patch_nodes in one call",
+            "do not create platform system workflow fields such as 当前流程状态 / 当前处理人 / 当前处理节点 / 流程标题; use an explicit business status field instead",
+            "workflow readback is app_flow_get; use app_flow_get_schema when raw spec shape is unclear",
         ],
         "minimal_example": {
             "profile": "default",
             "app_key": "APP_KEY",
             "publish": True,
-            "spec": {
-                "nodes": [{"id": "n1", "type": "APPLICANT", "name": "发起"}],
-                "transitions": [],
-            },
+            "spec": {"schemaVersion": "1", "nodes": [], "edges": []},
+        },
+        "patch_nodes_example": {
+            "profile": "default",
+            "app_key": "APP_KEY",
+            "publish": True,
+            "patch_nodes": [{"id": "approve_1", "set": {"name": "主管审批"}}],
         },
     },
     "app_views_plan": {
@@ -5768,11 +7806,15 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "upsert_views[].columns",
             "upsert_views[].filters",
             "upsert_views[].buttons",
+            "upsert_views[].action_buttons",
+            "upsert_views[].action_buttons_mode",
             "upsert_views[].visibility",
             "upsert_views[].query_conditions",
             "patch_views[].view_key",
             "patch_views[].name",
             "patch_views[].set",
+            "patch_views[].set.action_buttons",
+            "patch_views[].set.action_buttons_mode",
             "patch_views[].unset",
         ],
         "aliases": {
@@ -5800,6 +7842,14 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "buttons[].buttonFormula": "buttons[].button_formula",
             "buttons[].buttonFormulaType": "buttons[].button_formula_type",
             "buttons[].printTpls": "buttons[].print_tpls",
+            "actionButtons": "action_buttons",
+            "actionButtonsMode": "action_buttons_mode",
+            "action_buttons[].button_text": "action_buttons[].text",
+            "action_buttons[].trigger_action": "action_buttons[].action",
+            "action_buttons[].trigger_link_url": "action_buttons[].url",
+            "action_buttons[].visibleWhen": "action_buttons[].visible_when",
+            "action_buttons[].fieldMappings": "action_buttons[].field_mappings",
+            "action_buttons[].defaultValues": "action_buttons[].default_values",
         },
         "allowed_values": {
             "preset": [member.value for member in ViewsPreset],
@@ -5807,6 +7857,9 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "view.filter.operator": [member.value for member in ViewFilterOperator],
             "view.buttons.button_type": ["SYSTEM", "CUSTOM"],
             "view.buttons.config_type": ["TOP", "DETAIL", "INSIDE"],
+            "view.action_buttons.action": ["add_data", "link", "qRobot", "wings"],
+            "view.action_buttons.placement": [member.value for member in PublicButtonPlacement],
+            "view.action_buttons_mode": ["merge", "replace"],
             **deepcopy(_VISIBILITY_ALLOWED_VALUES),
         },
         "execution_notes": [
@@ -5816,6 +7869,9 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "upsert_views[].query_conditions.rows is a layout matrix of query-panel supported field names; it is compiled to backend queryCondition queIds",
             "do not put relation/attachment/subtable/code_block/q_linker/address fields in query_conditions; use filters for fixed filters or app_associated_resources_apply.match_mappings for current-record relation/report matching",
             "use patch_views for partial parameter replacement on existing views; the tool reads current config, merges patch_views[].set/unset, then submits the backend full-save payload internally",
+            "business buttons should be declared with action_buttons on the target view; app_views_apply writes the view first, then compiles action_buttons through the custom button writer and binds them to the resulting view_key",
+            "action_buttons_mode defaults to merge; replace rewrites this view's custom button bindings, and replace plus action_buttons=[] clears this view's custom button bindings without deleting button bodies",
+            "legacy upsert_views[].buttons is a compatibility path for raw full replacement of existing view button config; do not use it as the normal agent path",
             "remove_views accepts a raw view_key or an exact unique view name; after DELETE the tool verifies deletion by single view_key readback, not by a full app view list",
             "deleted views return verification.by_view[].delete_executed, readback_status, and safe_to_retry_delete=false; if readback is pending, do not blindly repeat the delete",
             "do not create business views named 全部数据, 我的数据, 我发起的, 待办, 已办, or 抄送; these are built-in system/default views. Use business-specific names for new views, and pass the existing raw view_key or patch_views when changing a built-in view",
@@ -5846,6 +7902,27 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             ],
             "remove_views": [],
         },
+        "action_buttons_example": {
+            "profile": "default",
+            "app_key": "APP_KEY",
+            "upsert_views": [
+                {
+                    "name": "生产工单执行视图",
+                    "type": "table",
+                    "columns": ["工单编号", "产品", "状态", "负责人"],
+                    "action_buttons": [
+                        {
+                            "text": "开始生产",
+                            "action": "link",
+                            "url": "https://example.com/start",
+                            "placement": "list",
+                            "visible_when": [{"field_name": "状态", "operator": "eq", "value": "待排产"}],
+                        }
+                    ],
+                }
+            ],
+            "remove_views": [],
+        },
         "full_upsert_query_conditions_example": {
             "profile": "default",
             "app_key": "APP_KEY",
@@ -5892,6 +7969,17 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
     },
     "app_views_apply": {
         "allowed_keys": [
+            "views",
+            "views[].operation",
+            "views[].app_key",
+            "views[].view_key",
+            "views[].name",
+            "views[].type",
+            "views[].columns",
+            "views[].filters",
+            "views[].action_buttons",
+            "views[].set",
+            "views[].unset",
             "app_key",
             "publish",
             "upsert_views",
@@ -5903,11 +7991,15 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "upsert_views[].columns",
             "upsert_views[].filters",
             "upsert_views[].buttons",
+            "upsert_views[].action_buttons",
+            "upsert_views[].action_buttons_mode",
             "upsert_views[].visibility",
             "upsert_views[].query_conditions",
             "patch_views[].view_key",
             "patch_views[].name",
             "patch_views[].set",
+            "patch_views[].set.action_buttons",
+            "patch_views[].set.action_buttons_mode",
             "patch_views[].unset",
         ],
         "aliases": {
@@ -5923,6 +8015,10 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "queryConditions": "query_conditions",
             "query_condition": "query_conditions",
             "queryCondition": "query_conditions",
+            "views[].op": "views[].operation",
+            "views[].fields": "views[].columns",
+            "views[].viewKey": "views[].view_key",
+            "views[].actionButtons": "views[].action_buttons",
             "patchViews": "patch_views",
             "startField": "start_field",
             "endField": "end_field",
@@ -5935,21 +8031,39 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "buttons[].buttonFormula": "buttons[].button_formula",
             "buttons[].buttonFormulaType": "buttons[].button_formula_type",
             "buttons[].printTpls": "buttons[].print_tpls",
+            "actionButtons": "action_buttons",
+            "actionButtonsMode": "action_buttons_mode",
+            "action_buttons[].button_text": "action_buttons[].text",
+            "action_buttons[].trigger_action": "action_buttons[].action",
+            "action_buttons[].trigger_link_url": "action_buttons[].url",
+            "action_buttons[].visibleWhen": "action_buttons[].visible_when",
+            "action_buttons[].fieldMappings": "action_buttons[].field_mappings",
+            "action_buttons[].defaultValues": "action_buttons[].default_values",
         },
         "allowed_values": {
+            "views[].operation": ["upsert", "patch", "remove"],
             "view.type": [member.value for member in PublicViewType],
             "view.filter.operator": [member.value for member in ViewFilterOperator],
             "view.buttons.button_type": ["SYSTEM", "CUSTOM"],
             "view.buttons.config_type": ["TOP", "DETAIL", "INSIDE"],
+            "view.action_buttons.action": ["add_data", "link", "qRobot", "wings"],
+            "view.action_buttons.placement": [member.value for member in PublicButtonPlacement],
+            "view.action_buttons_mode": ["merge", "replace"],
             **deepcopy(_VISIBILITY_ALLOWED_VALUES),
         },
         "execution_notes": [
+            "preferred batch input is views[]; each item has app_key and operation=upsert/patch/remove, and the same batch may mix same-app and cross-app views",
+            f"views[] jobs run concurrently with an internal limit of {VIEW_APPLY_PARALLEL_LIMIT}; results are returned in input order",
             "apply may return partial_success when some views land and others fail",
             "creating a new view follows backend createViewgraphConfig and requires both ViewManagementAuth and DataManageAuth; updating/deleting existing views only requires ViewManagementAuth",
             "when duplicate view names exist, supply view_key to target the exact view",
             "read back app_get after any failed or partial view apply",
             "view existence verification and saved-filter verification are separate; treat filters as unverified until verification.view_filters_verified is true",
             "buttons omitted preserves existing button config; buttons=[] clears all buttons; buttons=[...] replaces the full button config",
+            "business buttons should be declared with action_buttons on the target view; app_views_apply writes the view first, then compiles action_buttons through the custom button writer and binds them to the resulting view_key",
+            "patch_views[].set.action_buttons can add buttons to an existing view without rewriting columns/filters; action_buttons_mode defaults to merge, replace rewrites this view's custom button bindings, and replace plus action_buttons=[] clears bindings without deleting button bodies",
+            "publish=false with action_buttons is blocked as VIEW_ACTION_BUTTONS_REQUIRE_PUBLISH because the underlying custom button writer may publish after successful button writes",
+            "legacy upsert_views[].buttons is a compatibility path for raw full replacement of existing view button config; do not use it as the normal agent path",
             "upsert_views[].visibility may set per-view visibility; omit it to preserve an existing view's auth or default a new view to workspace/not",
             "filters are saved fixed filters that apply when the view opens; query_conditions configure the frontend query panel and only apply after a user enters query values",
             "upsert_views[].query_conditions.rows is a layout matrix of query-panel supported field names; it is compiled to backend queryCondition queIds",
@@ -5965,10 +8079,8 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
         ],
         "minimal_example": {
             "profile": "default",
-            "app_key": "APP_KEY",
             "publish": True,
-            "upsert_views": [{"name": "项目台账视图", "type": "table", "columns": ["项目名称"], "visibility": deepcopy(_VISIBILITY_WORKSPACE_EXAMPLE)}],
-            "remove_views": [],
+            "views": [{"operation": "upsert", "app_key": "APP_KEY", "name": "项目台账视图", "type": "table", "columns": ["项目名称"], "visibility": deepcopy(_VISIBILITY_WORKSPACE_EXAMPLE)}],
         },
         "query_conditions_example": {
             "profile": "default",
@@ -5987,6 +8099,51 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             ],
             "remove_views": [],
         },
+        "action_buttons_example": {
+            "profile": "default",
+            "app_key": "APP_KEY",
+            "publish": True,
+            "upsert_views": [
+                {
+                    "name": "生产工单执行视图",
+                    "type": "table",
+                    "columns": ["工单编号", "产品", "状态", "负责人"],
+                    "action_buttons": [
+                        {
+                            "text": "开始生产",
+                            "action": "link",
+                            "url": "https://example.com/start",
+                            "placement": "list",
+                            "visible_when": [{"field_name": "状态", "operator": "eq", "value": "待排产"}],
+                        }
+                    ],
+                }
+            ],
+            "remove_views": [],
+        },
+        "action_buttons_patch_example": {
+            "profile": "default",
+            "app_key": "APP_KEY",
+            "publish": True,
+            "patch_views": [
+                {
+                    "view_key": "RAW_VIEW_KEY",
+                    "set": {
+                        "action_buttons": [
+                            {
+                                "text": "创建验收单",
+                                "action": "add_data",
+                                "target_app_key": "ARRIVAL_APP",
+                                "field_mappings": [{"source_field": "数据ID", "target_field": "关联工单"}],
+                                "default_values": {"状态": "待验收"},
+                                "placement": "detail",
+                            }
+                        ]
+                    },
+                }
+            ],
+            "remove_views": [],
+        },
         "full_upsert_query_conditions_example": {
             "profile": "default",
             "app_key": "APP_KEY",
@@ -6102,8 +8259,8 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
         "aliases": {},
         "allowed_values": {},
         "execution_notes": [
-            "returns WorkflowSpecDTO for one app (alias of app_flow_get)",
-            "use app_flow_get_schema then app_flow_get before app_flow_apply",
+            "returns workflow configuration summary for one app",
+            "use this before app_flow_apply when you need the current node structure",
         ],
         "minimal_example": {
             "profile": "default",
@@ -6256,21 +8413,48 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
         },
     },
     "portal_apply": {
-        "allowed_keys": ["dash_key", "dash_name", "name", "package_id", "publish", "sections", "pages", "payload", "layout_preset", "visibility", "auth", "icon", "color", "hide_copyright", "dash_global_config", "config"],
+        "allowed_keys": ["dash_key", "dash_name", "name", "package_id", "publish", "sections", "patch_sections", "pages", "payload", "layout_preset", "visibility", "auth", "icon", "color", "hide_copyright", "dash_global_config", "config"],
         "aliases": {
             "packageId": "package_id",
             "name": "dash_name",
             "sourceType": "source_type",
             "chartRef": "chart_ref",
+            "inlineChart": "chart",
+            "createChart": "chart",
             "viewRef": "view_ref",
             "dashStyleConfigBO": "dash_style_config",
         },
-        "section_allowed_keys": ["title", "source_type", "role", "position", "dash_style_config", "config", "chart_ref", "view_ref", "text", "url"],
+        "section_allowed_keys": [
+            "title",
+            "source_type",
+            "role",
+            "position",
+            "dash_style_config",
+            "config",
+            "chart",
+            "chart.app_key",
+            "chart.name",
+            "chart.chart_name",
+            "chart.chart_type",
+            "chart.metric",
+            "chart.metrics",
+            "chart.group_by",
+            "chart.where",
+            "chart.filters",
+            "chart.chart_id",
+            "chart.chart_key",
+            "chart_ref",
+            "view_ref",
+            "text",
+            "url",
+        ],
         "section_aliases": {
             "sourceType": "source_type",
             "zone": "role",
             "sectionRole": "role",
             "chartRef": "chart_ref",
+            "inlineChart": "chart",
+            "createChart": "chart",
             "viewRef": "view_ref",
             "dashStyleConfigBO": "dash_style_config",
         },
@@ -6295,7 +8479,9 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "remove a section by omitting it from the new sections list",
             "package_id is required when creating a new portal",
             "publish=false only guarantees draft and base-info updates; it does not claim live has changed",
-            "chart_ref resolves by chart_id first, then exact unique chart_name",
+            "sections[].chart is the canonical QingBI chart field: chart_id/chart_key/chart_name references existing charts, while app_key+name/chart_type creates or updates app-source charts inline",
+            f"portal inline chart creation runs as chart jobs with an internal parallel limit of {PORTAL_INLINE_CHART_MAX_WORKERS}; identical same-app chart definitions are reused, conflicting duplicates are rejected",
+            "chart_ref and inline_chart remain compatibility aliases; do not use them as the normal agent path",
             "view_ref resolves by view_key first, then exact unique view_name",
             "pc layout uses a 24-column grid; mobile layout uses a 6-column grid",
             "if unsure about layout, omit position or use layout_preset=auto/dashboard_2col/dashboard_3col",
@@ -6323,7 +8509,12 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
                 {
                     "title": "经营概览",
                     "source_type": "chart",
-                    "chart_ref": {"app_key": "APP_KEY", "chart_name": "数据总量"},
+                    "chart": {
+                        "app_key": "APP_KEY",
+                        "name": "数据总量",
+                        "chart_type": "summary",
+                        "metric": {"field": "数据ID", "agg": "count"},
+                    },
                     "position": {
                         "pc": {"x": 0, "y": 0, "cols": 12, "rows": 6},
                         "mobile": {"x": 0, "y": 0, "cols": 6, "rows": 6},
@@ -6342,7 +8533,7 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
                         {
                             "title": "销售趋势",
                             "source_type": "chart",
-                            "chart_ref": {"app_key": "APP_KEY", "chart_id": "CHART_ID"},
+                            "chart": {"chart_id": "CHART_ID"},
                         }
                     ],
                 }
@@ -6409,6 +8600,7 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
 _PRIVATE_BUILDER_TOOL_CONTRACTS = {
     "app_schema_plan",
     "app_layout_plan",
+    "app_flow_plan",
     "app_views_plan",
 }