@josephyan/qingflow-app-builder-mcp 0.1.0-beta.13 → 0.1.0-beta.14

package/README.md

@@ -3,13 +3,13 @@
 Install:
 
 ```bash
-npm install @josephyan/qingflow-app-builder-mcp@0.1.0-beta.13
+npm install @josephyan/qingflow-app-builder-mcp@0.1.0-beta.14
 ```
 
 Run:
 
 ```bash
-npx -y -p @josephyan/qingflow-app-builder-mcp@0.1.0-beta.13 qingflow-app-builder-mcp
+npx -y -p @josephyan/qingflow-app-builder-mcp@0.1.0-beta.14 qingflow-app-builder-mcp
 ```
 
 Environment:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-app-builder-mcp",
-  "version": "0.1.0-beta.13",
+  "version": "0.1.0-beta.14",
   "description": "Builder MCP for Qingflow app/package/system design and staged solution workflows.",
   "license": "MIT",
   "type": "module",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qingflow-mcp"
-version = "0.1.0b13"
+version = "0.1.0b14"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/src/qingflow_mcp/__init__.py

@@ -2,4 +2,4 @@ from __future__ import annotations
 
 __all__ = ["__version__"]
 
-__version__ = "0.1.0b13"
+__version__ = "0.1.0b14"

package/src/qingflow_mcp/server_app_builder.py

@@ -229,6 +229,8 @@ def build_builder_server() -> FastMCP:
         requirement_text: str = "",
         package_tag_id: int = 0,
         package_name: str = "",
+        app_key: str = "",
+        update_only: bool = False,
         layout_style: str = "auto",
         publish: bool = True,
         run_label: str | None = None,
@@ -242,6 +244,8 @@ def build_builder_server() -> FastMCP:
             requirement_text=requirement_text,
             package_tag_id=package_tag_id,
             package_name=package_name,
+            app_key=app_key,
+            update_only=update_only,
             layout_style=layout_style,
             publish=publish,
             run_label=run_label,
@@ -278,6 +282,9 @@ def build_builder_server() -> FastMCP:
         mode: str = "plan",
         build_id: str = "",
         app_spec: dict | None = None,
+        app_key: str = "",
+        package_tag_id: int = 0,
+        update_only: bool = False,
         publish: bool = True,
         run_label: str | None = None,
         target: dict | None = None,
@@ -288,6 +295,9 @@ def build_builder_server() -> FastMCP:
             mode=mode,
             build_id=build_id,
             app_spec=app_spec or {},
+            app_key=app_key,
+            package_tag_id=package_tag_id,
+            update_only=update_only,
             publish=publish,
             run_label=run_label,
             target=target or {},

package/src/qingflow_mcp/solution/compiler/__init__.py

@@ -128,8 +128,13 @@ def compile_role(role: RoleSpec) -> CompiledRole:
     return CompiledRole(role_id=role.role_id, name=role.name, payload=payload)
 
 
-def build_execution_plan(spec: SolutionSpec, include_package: bool) -> ExecutionPlan:
+def build_execution_plan(
+    spec: SolutionSpec,
+    include_package: bool,
+    attach_package: bool | None = None,
+) -> ExecutionPlan:
     steps: list[ExecutionStep] = []
+    attach_package = include_package if attach_package is None else attach_package
     if include_package:
         steps.append(ExecutionStep("package.create", "package", spec.package.name or spec.solution_name, "创建应用包"))
     for role in spec.roles:
@@ -139,7 +144,19 @@ def build_execution_plan(spec: SolutionSpec, include_package: bool) -> Execution
         entity_ref = entity.entity_id
         dependencies = ["package.create"] if include_package else []
         steps.append(ExecutionStep(f"app.create.{entity_ref}", "app", entity_ref, f"创建应用 {entity.display_name}", dependencies.copy()))
-        steps.append(ExecutionStep(f"form.base.{entity_ref}", "form", entity_ref, f"写入基础表单 {entity.display_name}", [f"app.create.{entity_ref}"]))
+        last_form_step = f"app.create.{entity_ref}"
+        if attach_package:
+            steps.append(
+                ExecutionStep(
+                    f"package.attach.{entity_ref}",
+                    "package_attach",
+                    entity_ref,
+                    f"将应用加入应用包 {entity.display_name}",
+                    [f"app.create.{entity_ref}"],
+                )
+            )
+            last_form_step = f"package.attach.{entity_ref}"
+        steps.append(ExecutionStep(f"form.base.{entity_ref}", "form", entity_ref, f"写入基础表单 {entity.display_name}", [last_form_step]))
         last_form_step = f"form.base.{entity_ref}"
         if any(field.type.value == "relation" for field in entity.fields):
             steps.append(ExecutionStep(f"form.relations.{entity_ref}", "form", entity_ref, f"回填关联字段 {entity.display_name}", [f"form.base.{entity_ref}"]))

package/src/qingflow_mcp/solution/executor.py

@@ -24,6 +24,7 @@ from .spec_models import FieldType
 NAVIGATION_PLUGIN_ID = 45
 GRID_COMPONENT_PLUGIN_ID = 34
 BI_CHART_COMPONENT_TYPE = 9
+PACKAGE_ITEM_TYPE_FORM = 1
 
 
 class SolutionExecutor:
@@ -90,6 +91,17 @@ class SolutionExecutor:
             context["resource"] = "package"
             context["package_name"] = compiled.normalized_spec.package.name or compiled.normalized_spec.solution_name
             return context
+        if step_name.startswith("package.attach."):
+            entity = self._entity_from_step(compiled, step_name)
+            context.update(
+                {
+                    "resource": "package_attach",
+                    "entity_id": entity.entity_id,
+                    "display_name": entity.display_name,
+                    "package_tag_id": self._current_store.get_artifact("package", "tag_id") if hasattr(self, "_current_store") else None,
+                }
+            )
+            return context
         if step_name == "portal.create":
             context["resource"] = "portal"
             context["portal_name"] = compiled.normalized_spec.portal.name
@@ -125,6 +137,10 @@ class SolutionExecutor:
         if step_name == "package.create":
             self._create_package(profile, compiled, store)
             return
+        if step_name.startswith("package.attach."):
+            entity = self._entity_from_step(compiled, step_name)
+            self._attach_app_to_package(profile, entity, store)
+            return
         if step_name.startswith("role.create."):
             role = self._role_from_step(compiled, step_name)
             self._create_role(profile, role, store)
@@ -261,6 +277,10 @@ class SolutionExecutor:
         existing_artifact = store.get_artifact("apps", entity.entity_id, {}) or {}
         existing_app_key = existing_artifact.get("app_key")
         if isinstance(existing_app_key, str) and existing_app_key:
+            next_artifact = deepcopy(existing_artifact)
+            next_artifact["reused"] = True
+            next_artifact.setdefault("target_mode", "update")
+            store.set_artifact("apps", entity.entity_id, next_artifact)
             return
         payload = self._resolve_app_payload(entity.app_create_payload, store)
         result = self.app_tools.app_create(profile=profile, payload=payload)
@@ -283,6 +303,64 @@ class SolutionExecutor:
                 store.set_artifact("apps", entity.entity_id, app_artifact)
                 raise
 
+    def _attach_app_to_package(self, profile: str, entity: CompiledEntity, store: RunArtifactStore) -> None:
+        tag_id = store.get_artifact("package", "tag_id")
+        if not isinstance(tag_id, int) or tag_id <= 0:
+            return
+        app_artifact = store.get_artifact("apps", entity.entity_id, {}) or {}
+        app_key = app_artifact.get("app_key")
+        if not isinstance(app_key, str) or not app_key:
+            raise ValueError(f"missing app_key for package attach on entity '{entity.entity_id}'")
+
+        package_detail = self.package_tools.package_get(profile=profile, tag_id=tag_id, include_raw=True)
+        package_result = package_detail.get("result") if isinstance(package_detail.get("result"), dict) else {}
+        tag_items = [deepcopy(item) for item in package_result.get("tagItems", []) if isinstance(item, dict)]
+        if any(_package_item_app_key(item) == app_key for item in tag_items):
+            self._record_package_attachment(store, entity.entity_id, app_artifact, tag_id=tag_id, attached=True, reused=True)
+            return
+
+        item = {
+            "itemType": PACKAGE_ITEM_TYPE_FORM,
+            "appKey": app_key,
+            "title": entity.display_name,
+            "iconUrl": entity.app_create_payload.get("appIcon"),
+        }
+        insert_at = _resolve_package_item_insert_index(tag_items, entity.app_create_payload.get("ordinal"))
+        updated_items = list(tag_items)
+        updated_items.insert(insert_at, item)
+        self.package_tools.package_update(profile=profile, tag_id=tag_id, payload={"tagItems": updated_items})
+
+        verified_detail = self.package_tools.package_get(profile=profile, tag_id=tag_id, include_raw=True)
+        verified_result = verified_detail.get("result") if isinstance(verified_detail.get("result"), dict) else {}
+        verified_items = [deepcopy(existing) for existing in verified_result.get("tagItems", []) if isinstance(existing, dict)]
+        if not any(_package_item_app_key(existing) == app_key for existing in verified_items):
+            raise QingflowApiError(
+                category="runtime",
+                message=f"failed to attach app '{app_key}' to package '{tag_id}'",
+                details={"tag_id": tag_id, "app_key": app_key},
+            )
+        store.set_artifact("package", "result", verified_detail)
+        store.set_artifact("package", "tag_id", tag_id)
+        self._record_package_attachment(store, entity.entity_id, app_artifact, tag_id=tag_id, attached=True, reused=False)
+
+    def _record_package_attachment(
+        self,
+        store: RunArtifactStore,
+        entity_id: str,
+        app_artifact: dict[str, Any],
+        *,
+        tag_id: int,
+        attached: bool,
+        reused: bool,
+    ) -> None:
+        next_artifact = deepcopy(app_artifact)
+        next_artifact["package_attachment"] = {
+            "tag_id": tag_id,
+            "attached": attached,
+            "reused": reused,
+        }
+        store.set_artifact("apps", entity_id, next_artifact)
+
     def _update_form_base(self, profile: str, entity: CompiledEntity, store: RunArtifactStore) -> None:
         app_key = self._get_app_key(store, entity.entity_id)
         payload = deepcopy(entity.form_base_payload)
@@ -2156,6 +2234,20 @@ def _flatten_questions(value: Any) -> list[dict[str, Any]]:
     return []
 
 
+def _package_item_app_key(item: dict[str, Any]) -> str | None:
+    item_type = item.get("itemType")
+    if item_type is not None and item_type not in {PACKAGE_ITEM_TYPE_FORM, str(PACKAGE_ITEM_TYPE_FORM)}:
+        return None
+    app_key = item.get("appKey")
+    return app_key if isinstance(app_key, str) and app_key else None
+
+
+def _resolve_package_item_insert_index(tag_items: list[dict[str, Any]], ordinal: Any) -> int:
+    if not isinstance(ordinal, int) or ordinal <= 0:
+        return len(tag_items)
+    return max(0, min(len(tag_items), ordinal - 1))
+
+
 def _build_viewgraph_questions(schema: dict[str, Any], visible_que_ids: list[int]) -> list[dict[str, Any]]:
     visible_map = {que_id: index for index, que_id in enumerate(visible_que_ids, start=1)}
     questions: list[dict[str, Any]] = []

package/src/qingflow_mcp/solution/requirements_builder.py

@@ -351,7 +351,22 @@ def _build_relation_field(*, requirement_text: str, entity_id: str) -> dict[str,
             "relation field requires an explicit target entity; specify what it should relate to",
             missing_required_fields=["relation.target_entity_id"],
             invalid_field_types=["relation"],
-            details={"requested_field_type": "relation"},
+            details={
+                "requested_field_type": "relation",
+                "suggested_requirement_hint": "例如：关联到客户档案。",
+                "suggested_patch": {
+                    "entities": [
+                        {
+                            "entity_id": "target_entity",
+                            "display_name": "目标应用",
+                            "kind": EntityKind.master.value,
+                            "title_field_id": "title",
+                            "fields": [{"field_id": "title", "label": "标题", "type": FieldType.text.value, "required": True}],
+                            "form_layout": {"rows": [{"field_ids": ["title"]}]},
+                        }
+                    ]
+                },
+            },
         )
     target_entity_id = entity_id if target_phrase in {"当前应用", "当前表单", "自身", "本应用"} else _slugify_identifier(target_phrase, prefix="entity")
     field = _clone_field_blueprint(FIELD_BLUEPRINTS_BY_TYPE[FieldType.relation.value])
@@ -366,7 +381,28 @@ def _build_subtable_field(*, requirement_text: str) -> dict[str, Any]:
             "subtable field requires explicit child field definitions; specify the row fields first",
             missing_required_fields=["subtable.subfields"],
             invalid_field_types=["subtable"],
-            details={"requested_field_type": "subtable"},
+            details={
+                "requested_field_type": "subtable",
+                "suggested_requirement_hint": "例如：明细表字段包括 子项名称、数量、金额。",
+                "suggested_patch": {
+                    "entities": [
+                        {
+                            "fields": [
+                                {
+                                    "field_id": "detail_items",
+                                    "label": "明细",
+                                    "type": FieldType.subtable.value,
+                                    "subfields": [
+                                        {"field_id": "item_name", "label": "子项名称", "type": FieldType.text.value, "required": True},
+                                        {"field_id": "quantity", "label": "数量", "type": FieldType.number.value},
+                                        {"field_id": "amount", "label": "金额", "type": FieldType.amount.value},
+                                    ],
+                                }
+                            ]
+                        }
+                    ]
+                },
+            },
         )
     field = _clone_field_blueprint(FIELD_BLUEPRINTS_BY_TYPE[FieldType.subtable.value])
     field["subfields"] = subfields

package/src/qingflow_mcp/tools/solution_tools.py

@@ -45,6 +45,8 @@ STAGED_BUILD_MODE_ALIASES = {
     "new": "plan",
     "start": "plan",
     "draft": "plan",
+    "update": "plan",
+    "modify": "plan",
     "preview": "preflight",
     "prepare": "preflight",
     "run": "apply",
@@ -60,7 +62,7 @@ STAGE_TOOL_NAMES = {
     "analytics_portal": "solution_build_analytics_portal",
     "navigation": "solution_build_navigation",
 }
-SOLUTION_SCHEMA_STAGES = {"app", "flow", "views", "analytics_portal", "navigation", "app_flow", "all"}
+SOLUTION_SCHEMA_STAGES = {"app", "app_update", "flow", "views", "analytics_portal", "navigation", "app_flow", "all"}
 SOLUTION_SCHEMA_INTENTS = {"minimal", "full", "demo"}
 SOLUTION_SCHEMA_STAGE_ALIASES = {
     "all": "all",
@@ -71,6 +73,12 @@ SOLUTION_SCHEMA_STAGE_ALIASES = {
     "form": "app",
     "schema": "app",
     "app_spec": "app",
+    "app_update": "app_update",
+    "update_app": "app_update",
+    "update": "app_update",
+    "更新应用": "app_update",
+    "更新表单": "app_update",
+    "更新schema": "app_update",
     "应用": "app",
     "表单": "app",
     "flow": "flow",
@@ -163,6 +171,9 @@ class SolutionTools(ToolBase):
             mode: str = "plan",
             build_id: str = "",
             app_spec: dict[str, Any] | None = None,
+            app_key: str = "",
+            package_tag_id: int = 0,
+            update_only: bool = False,
             publish: bool = True,
             run_label: str | None = None,
             target: dict[str, Any] | None = None,
@@ -173,6 +184,9 @@ class SolutionTools(ToolBase):
                 mode=mode,
                 build_id=build_id,
                 app_spec=app_spec or {},
+                app_key=app_key,
+                package_tag_id=package_tag_id,
+                update_only=update_only,
                 publish=publish,
                 run_label=run_label,
                 target=target or {},
@@ -188,6 +202,8 @@ class SolutionTools(ToolBase):
             requirement_text: str = "",
             package_tag_id: int = 0,
             package_name: str = "",
+            app_key: str = "",
+            update_only: bool = False,
             layout_style: str = "auto",
             publish: bool = True,
             run_label: str | None = None,
@@ -201,6 +217,8 @@ class SolutionTools(ToolBase):
                 requirement_text=requirement_text,
                 package_tag_id=package_tag_id,
                 package_name=package_name,
+                app_key=app_key,
+                update_only=update_only,
                 layout_style=layout_style,
                 publish=publish,
                 run_label=run_label,
@@ -528,6 +546,9 @@ class SolutionTools(ToolBase):
         mode: str,
         build_id: str,
         app_spec: dict[str, Any],
+        app_key: str = "",
+        package_tag_id: int = 0,
+        update_only: bool = False,
         publish: bool,
         run_label: str | None,
         target: dict[str, Any],
@@ -537,6 +558,12 @@ class SolutionTools(ToolBase):
         resolved_app_spec = deepcopy(app_spec) if isinstance(app_spec, dict) else {}
         if not resolved_app_spec and build_id:
             resolved_app_spec = self._load_generated_app_spec(build_id) or {}
+        resolved_target = _merge_app_target(
+            target,
+            app_key=app_key,
+            package_tag_id=package_tag_id,
+            update_only=update_only,
+        )
         return self._stage_build(
             profile=profile,
             mode=mode,
@@ -546,7 +573,7 @@ class SolutionTools(ToolBase):
             stage_model=AppBuildSpec,
             publish=publish,
             run_label=run_label,
-            target=target,
+            target=resolved_target,
             repair_patch=repair_patch,
             public_stage_name="app",
             tool_name="solution_build_app",
@@ -563,6 +590,8 @@ class SolutionTools(ToolBase):
         requirement_text: str,
         package_tag_id: int,
         package_name: str,
+        app_key: str = "",
+        update_only: bool = False,
         layout_style: str,
         publish: bool,
         run_label: str | None,
@@ -571,6 +600,12 @@ class SolutionTools(ToolBase):
         mode = _normalize_staged_build_mode(mode)
         if mode in {"preflight", "plan"} and not build_id:
             build_id = _generate_build_id(run_label=run_label, stage_name="app")
+        resolved_target = _merge_app_target(
+            {},
+            app_key=app_key,
+            package_tag_id=package_tag_id,
+            update_only=update_only,
+        )
         resolved_package = self._resolve_builder_package_reference(
             profile=profile,
             package_tag_id=package_tag_id,
@@ -578,11 +613,20 @@ class SolutionTools(ToolBase):
         )
         if resolved_package.get("status") == "failed":
             return resolved_package["response"]
+        existing_app = self._resolve_builder_existing_app_reference(
+            profile=profile,
+            app_key=app_key,
+            package_resolution=resolved_package,
+            update_only=_target_is_update_only(resolved_target),
+        )
+        if existing_app.get("status") == "failed":
+            return existing_app["response"]
+        effective_package_resolution = existing_app.get("package_resolution") if existing_app.get("package_resolution") else resolved_package
         try:
             generated = build_app_spec_from_requirements(
                 title=title,
                 requirement_text=requirement_text,
-                package_name=resolved_package.get("tag_name"),
+                package_name=effective_package_resolution.get("tag_name"),
                 layout_style=layout_style,
             )
         except RequirementsBuildError as exc:
@@ -591,7 +635,9 @@ class SolutionTools(ToolBase):
                 build_id=build_id,
                 title=title,
                 requirement_text=requirement_text,
-                package_resolution=resolved_package,
+                package_resolution=effective_package_resolution,
+                app_key=app_key,
+                update_only=_target_is_update_only(resolved_target),
                 layout_style=layout_style,
                 publish=publish,
                 run_label=run_label,
@@ -608,7 +654,9 @@ class SolutionTools(ToolBase):
                 build_id=build_id,
                 title=title,
                 requirement_text=requirement_text,
-                package_resolution=resolved_package,
+                package_resolution=effective_package_resolution,
+                app_key=app_key,
+                update_only=_target_is_update_only(resolved_target),
                 layout_style=layout_style,
                 publish=publish,
                 run_label=run_label,
@@ -618,7 +666,7 @@ class SolutionTools(ToolBase):
             self._persist_generated_app_spec(
                 build_id=build_id,
                 generated=generated,
-                package_resolution=resolved_package,
+                package_resolution=effective_package_resolution,
                 title=title,
                 requirement_text=requirement_text,
                 layout_style=layout_style,
@@ -628,16 +676,23 @@ class SolutionTools(ToolBase):
             mode=mode,
             build_id=build_id,
             app_spec=generated.app_spec,
+            app_key=app_key,
+            package_tag_id=int(effective_package_resolution.get("tag_id") or 0),
+            update_only=_target_is_update_only(resolved_target),
             publish=publish,
             run_label=run_label,
-            target=_requirements_target(resolved_package),
+            target=_requirements_target(
+                effective_package_resolution,
+                app_key=app_key if isinstance(app_key, str) else "",
+                update_only=_target_is_update_only(resolved_target),
+            ),
             repair_patch={},
         )
         return self._requirements_success_response(
             mode=mode,
             title=title,
             requirement_text=requirement_text,
-            package_resolution=resolved_package,
+            package_resolution=effective_package_resolution,
             layout_style=layout_style,
             publish=publish,
             run_label=run_label,
@@ -1101,9 +1156,18 @@ class SolutionTools(ToolBase):
             parsed_manifest = BuildManifest.model_validate(merged_manifest)
             normalized_manifest = normalize_solution_spec(parsed_manifest)
             compiled = compile_solution(normalized_manifest)
+            existing_app_targets = _resolve_target_app_keys(
+                target=target,
+                entity_ids=[entity.entity_id for entity in compiled.entities],
+            )
+            update_only = _target_is_update_only(target) or bool(existing_app_targets)
+            if update_only and not existing_app_targets:
+                raise ValueError("update target requires app_key or target.app_keys")
             package_tag_id = _resolve_target_package_tag_id(target)
             if package_tag_id is not None:
                 compiled = _bind_existing_package_target(compiled, package_tag_id)
+            elif update_only:
+                compiled = _bind_existing_app_target(compiled)
             filtered_compiled = _filter_compiled_solution(
                 compiled,
                 stage_name=stage_name,
@@ -1112,6 +1176,8 @@ class SolutionTools(ToolBase):
             )
             assembly.set_stage_spec(stage_name, resolved_stage_payload)
             assembly.set_manifest(normalized_manifest.model_dump(mode="json"))
+            if existing_app_targets:
+                _seed_existing_app_artifacts(assembly=assembly, existing_app_targets=existing_app_targets)
 
             if mode in {"preflight", "plan"}:
                 status = "preflighted" if mode == "preflight" else "planned"
@@ -1170,11 +1236,24 @@ class SolutionTools(ToolBase):
                 mode=mode,
             )
             assembly.set_artifacts(result["artifacts"])
+            stage_verification = None
+            effective_status = result["status"]
+            if result["status"] == "success":
+                stage_verification = self._verify_stage_write_result(
+                    profile=profile,
+                    build_id=build_id,
+                    public_stage_name=public_stage_name,
+                    artifacts=result["artifacts"],
+                    solution_spec=normalized_manifest.model_dump(mode="json"),
+                    target=target,
+                )
+                if isinstance(stage_verification, dict) and stage_verification.get("status") == "partial":
+                    effective_status = "partial_success"
             failure_signature = None
             stage_failure_count = 0
             next_strategy = None
             suggested_next_call_override = None
-            if result["status"] == "failed":
+            if effective_status == "failed":
                 failure_signature, stage_failure_count = self._record_failure_signature(
                     assembly=assembly,
                     stage_name=public_stage_name,
@@ -1191,12 +1270,12 @@ class SolutionTools(ToolBase):
                 {
                     "stage": stage_name,
                     "mode": mode,
-                    "status": result["status"],
+                    "status": effective_status,
                     "run_path": result["run_path"],
                     "execution_step_count": len(filtered_compiled.execution_plan.steps),
                 }
             )
-            assembly.mark_status(_build_status_for_stage(stage_name, result["status"]))
+            assembly.mark_status(_build_status_for_stage(stage_name, effective_status))
             response = self._stage_success_response(
                 build_id=build_id,
                 stage_name=public_stage_name,
@@ -1208,11 +1287,12 @@ class SolutionTools(ToolBase):
                 errors=result["errors"],
                 run_path=result["run_path"],
                 build_path=str(assembly.path),
-                status=result["status"],
+                status=effective_status,
                 build_summary=_build_summary(assembly),
                 tool_name=tool_name,
+                verification=stage_verification,
             )
-            if result["status"] == "failed":
+            if effective_status == "failed":
                 response["failure_signature"] = failure_signature
                 response["stage_failure_count"] = stage_failure_count or 1
             if next_strategy:
@@ -1415,6 +1495,100 @@ class SolutionTools(ToolBase):
             verification["status"] = "partial"
         return verification
 
+    def _verify_stage_write_result(
+        self,
+        *,
+        profile: str,
+        build_id: str,
+        public_stage_name: str,
+        artifacts: dict[str, Any],
+        solution_spec: dict[str, Any],
+        target: dict[str, Any],
+    ) -> dict[str, Any] | None:
+        if public_stage_name != "app":
+            return None
+        app_tools = AppTools(self.sessions, self.backend)
+        expected_package_tag_id = _resolve_target_package_tag_id(target)
+        verification: dict[str, Any] = {
+            "stage": public_stage_name,
+            "status": "success",
+            "expected_package_tag_id": expected_package_tag_id,
+            "package_attached": None if expected_package_tag_id is None else True,
+            "apps": [],
+            "views_created": [],
+            "views_strategy": "not_included",
+            "errors": [],
+        }
+        apps_artifact = artifacts.get("apps", {}) if isinstance(artifacts.get("apps"), dict) else {}
+        views_artifact = artifacts.get("views", {}) if isinstance(artifacts.get("views"), dict) else {}
+        entity_specs = {
+            entity.get("entity_id"): entity
+            for entity in solution_spec.get("entities", [])
+            if isinstance(entity, dict) and isinstance(entity.get("entity_id"), str)
+        }
+
+        for entity_id, app_info in apps_artifact.items():
+            if not isinstance(app_info, dict):
+                continue
+            app_key = app_info.get("app_key")
+            if not isinstance(app_key, str) or not app_key:
+                continue
+            try:
+                base_info = app_tools.app_get_base(profile=profile, app_key=app_key, include_raw=True).get("result") or {}
+                raw_tag_ids = base_info.get("tagIds") if isinstance(base_info.get("tagIds"), list) else []
+                tag_ids_after = [tag_id for tag_id in (_coerce_count(value) for value in raw_tag_ids) if tag_id is not None]
+                package_attached = None if expected_package_tag_id is None else expected_package_tag_id in tag_ids_after
+                if package_attached is False:
+                    verification["status"] = "partial"
+                    verification["package_attached"] = False
+                    verification["errors"].append(
+                        {
+                            "category": "verification",
+                            "detail": f"app '{app_key}' is not attached to expected package '{expected_package_tag_id}'",
+                            "entity_id": entity_id,
+                            "app_key": app_key,
+                            "tag_ids_after": tag_ids_after,
+                        }
+                    )
+                entity_views = views_artifact.get(entity_id) if isinstance(views_artifact.get(entity_id), dict) else {}
+                created_view_keys = sorted(
+                    {
+                        str(view_result.get("view_key"))
+                        for view_result in entity_views.values()
+                        if isinstance(view_result, dict) and isinstance(view_result.get("view_key"), str) and view_result.get("view_key")
+                    }
+                )
+                verification["views_created"].extend(created_view_keys)
+                verification["apps"].append(
+                    {
+                        "entity_id": entity_id,
+                        "display_name": entity_specs.get(entity_id, {}).get("display_name"),
+                        "app_key": app_key,
+                        "tag_ids_after": tag_ids_after,
+                        "package_attached": package_attached,
+                        "views_created": created_view_keys,
+                        "publish_status": base_info.get("appPublishStatus"),
+                    }
+                )
+            except Exception as exc:  # noqa: BLE001
+                verification["status"] = "partial"
+                verification["errors"].append(
+                    {
+                        "category": "verification",
+                        "detail": str(exc),
+                        "entity_id": entity_id,
+                        "app_key": app_key,
+                    }
+                )
+        if verification["views_created"]:
+            verification["views_strategy"] = "created"
+        else:
+            verification["suggested_next_call"] = {
+                "tool_name": "solution_build_views",
+                "arguments": {"mode": "plan", "build_id": build_id},
+            }
+        return verification
+
     def _failure_response(self, mode: str, idempotency_key: str, category: str, detail: Any) -> dict[str, Any]:
         error_fields = _solution_error_fields(
             category=category,
@@ -1458,6 +1632,8 @@ class SolutionTools(ToolBase):
             ),
             stage=stage_name,
         )
+        if build_id and stage_name == "app":
+            error_fields["suggested_schema_call"] = None
         return {
             "build_id": build_id,
             "stage": stage_name,
@@ -1521,8 +1697,9 @@ class SolutionTools(ToolBase):
         status: str,
         build_summary: dict[str, Any],
         tool_name: str,
+        verification: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
-        return {
+        response = {
             "build_id": build_id,
             "stage": stage_name,
             "mode": mode,
@@ -1535,6 +1712,7 @@ class SolutionTools(ToolBase):
             "errors": _sanitize_errors(errors),
             "build_path": build_path,
             "run_path": run_path,
+            "verification": verification,
             "build_summary": build_summary,
             "suggested_next_call": _solution_build_next_call(
                 tool_name=tool_name,
@@ -1542,6 +1720,11 @@ class SolutionTools(ToolBase):
                 build_id=build_id,
             ),
         }
+        if isinstance(verification, dict):
+            for key in ("package_attached", "views_created", "views_strategy"):
+                if key in verification:
+                    response[key] = verification.get(key)
+        return response
 
     def _design_failure_response(self, session_id: str, action: str, category: str, detail: Any) -> dict[str, Any]:
         error_fields = _solution_error_fields(
@@ -1761,6 +1944,116 @@ class SolutionTools(ToolBase):
             },
         }
 
+    def _resolve_builder_existing_app_reference(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        package_resolution: dict[str, Any],
+        update_only: bool,
+    ) -> dict[str, Any]:
+        normalized_app_key = str(app_key or "").strip()
+        if not normalized_app_key:
+            if update_only:
+                detail = "update target requires app_key"
+                error_fields = _solution_error_fields(category="config", detail=detail, suggested_next_call=None, stage="app")
+                error_fields["missing_required_fields"] = sorted(
+                    dict.fromkeys(list(error_fields.get("missing_required_fields", [])) + ["app_key"])
+                )
+                error_fields["suggested_schema_call"] = None
+                return {
+                    "status": "failed",
+                    "response": {
+                        "status": "failed",
+                        "stage": "app",
+                        "errors": [{"category": "config", "detail": detail}],
+                        **error_fields,
+                    },
+                }
+            return {"status": "none"}
+
+        app_tools = AppTools(self.sessions, self.backend)
+        try:
+            base_info = app_tools.app_get_base(profile=profile, app_key=normalized_app_key, include_raw=True).get("result") or {}
+        except Exception as exc:  # noqa: BLE001
+            detail = f"failed to resolve existing app '{normalized_app_key}': {exc}"
+            error_fields = _solution_error_fields(category="config", detail=detail, suggested_next_call=None, stage="app")
+            error_fields["suggested_schema_call"] = None
+            return {
+                "status": "failed",
+                "response": {
+                    "status": "failed",
+                    "stage": "app",
+                    "errors": [{"category": "config", "detail": detail}],
+                    **error_fields,
+                },
+            }
+
+        raw_tag_ids = base_info.get("tagIds") if isinstance(base_info.get("tagIds"), list) else []
+        tag_ids = [tag_id for tag_id in (_coerce_count(item) for item in raw_tag_ids) if tag_id is not None]
+        effective_package_resolution = deepcopy(package_resolution)
+        if package_resolution.get("status") == "resolved":
+            resolved_tag_id = _coerce_count(package_resolution.get("tag_id"))
+            if resolved_tag_id is not None and tag_ids and resolved_tag_id not in tag_ids:
+                detail = (
+                    f"app_key '{normalized_app_key}' does not belong to requested package "
+                    f"'{package_resolution.get('tag_name') or resolved_tag_id}'"
+                )
+                error_fields = _solution_error_fields(category="config", detail=detail, suggested_next_call=None, stage="app")
+                error_fields["error_code"] = "APP_PACKAGE_MISMATCH"
+                error_fields["suggested_schema_call"] = None
+                return {
+                    "status": "failed",
+                    "response": {
+                        "status": "failed",
+                        "stage": "app",
+                        "errors": [{"category": "config", "detail": detail}],
+                        "existing_app": {
+                            "app_key": normalized_app_key,
+                            "app_name": base_info.get("formTitle"),
+                            "tag_ids": tag_ids,
+                        },
+                        **error_fields,
+                    },
+                }
+        elif package_resolution.get("status") == "new_package":
+            if len(tag_ids) == 1:
+                package_tools = PackageTools(self.sessions, self.backend)
+                package_detail = package_tools.package_get(profile=profile, tag_id=tag_ids[0], include_raw=False).get("result") or {}
+                effective_package_resolution = {
+                    "status": "resolved",
+                    "matched_via": "existing_app",
+                    "tag_id": tag_ids[0],
+                    "tag_name": package_detail.get("tagName"),
+                    "candidates": [],
+                }
+            elif len(tag_ids) > 1:
+                detail = f"app_key '{normalized_app_key}' belongs to multiple packages; provide package_tag_id or package_name explicitly"
+                error_fields = _solution_error_fields(category="config", detail=detail, suggested_next_call=None, stage="app")
+                error_fields["error_code"] = "AMBIGUOUS_PACKAGE"
+                error_fields["suggested_schema_call"] = None
+                return {
+                    "status": "failed",
+                    "response": {
+                        "status": "failed",
+                        "stage": "app",
+                        "errors": [{"category": "config", "detail": detail}],
+                        "existing_app": {
+                            "app_key": normalized_app_key,
+                            "app_name": base_info.get("formTitle"),
+                            "tag_ids": tag_ids,
+                        },
+                        **error_fields,
+                    },
+                }
+        return {
+            "status": "resolved",
+            "app_key": normalized_app_key,
+            "app_name": base_info.get("formTitle"),
+            "package_resolution": effective_package_resolution,
+            "tag_ids": tag_ids,
+        }
+
     def _requirements_failure_response(
         self,
         *,
@@ -1769,6 +2062,8 @@ class SolutionTools(ToolBase):
         title: str,
         requirement_text: str,
         package_resolution: dict[str, Any],
+        app_key: str,
+        update_only: bool,
         layout_style: str,
         publish: bool,
         run_label: str | None,
@@ -1788,6 +2083,8 @@ class SolutionTools(ToolBase):
                 title=title,
                 requirement_text=requirement_text,
                 package_resolution=package_resolution,
+                app_key=app_key,
+                update_only=update_only,
                 layout_style=layout_style,
                 publish=publish,
                 run_label=run_label,
@@ -1823,6 +2120,8 @@ class SolutionTools(ToolBase):
             "failure_signature": None,
             "stage_failure_count": 0,
             "details": deepcopy(error_details or {}),
+            "suggested_requirement_hint": (error_details or {}).get("suggested_requirement_hint") if isinstance(error_details, dict) else None,
+            "suggested_patch": deepcopy((error_details or {}).get("suggested_patch")) if isinstance(error_details, dict) else None,
             **error_fields,
         }
 
@@ -1857,7 +2156,21 @@ class SolutionTools(ToolBase):
             "excluded_advanced_fields": generated.summary.get("excluded_advanced_fields"),
             "execution_step_count": len((stage_result.get("execution_plan") or {}).get("steps", [])),
             "suggested_next_call": next_call,
+            "views_strategy": _resolve_app_stage_views_strategy(stage_result),
         }
+        if isinstance(stage_result.get("verification"), dict):
+            verification = stage_result["verification"]
+            response["verification"] = verification
+            if "package_attached" in verification:
+                response["package_attached"] = verification.get("package_attached")
+            if isinstance(verification.get("apps"), list):
+                response["tag_ids_after"] = {
+                    str(item.get("entity_id")): item.get("tag_ids_after")
+                    for item in verification["apps"]
+                    if isinstance(item, dict) and item.get("entity_id") is not None
+                }
+            if isinstance(verification.get("views_created"), list):
+                response["views_created"] = verification.get("views_created")
         for key in (
             "error_code",
             "recoverable",
@@ -1967,6 +2280,8 @@ def _requirements_next_call(
     title: str,
     requirement_text: str,
     package_resolution: dict[str, Any],
+    app_key: str,
+    update_only: bool,
     layout_style: str,
     publish: bool,
     run_label: str | None,
@@ -1986,6 +2301,10 @@ def _requirements_next_call(
         arguments["package_tag_id"] = package_resolution["tag_id"]
     elif isinstance(package_resolution.get("tag_name"), str) and package_resolution["tag_name"]:
         arguments["package_name"] = package_resolution["tag_name"]
+    if isinstance(app_key, str) and app_key:
+        arguments["app_key"] = app_key
+    if update_only or arguments.get("app_key"):
+        arguments["update_only"] = True
     return {"tool_name": "solution_build_app_from_requirements", "arguments": arguments}
 
 
@@ -1995,6 +2314,8 @@ def _rewrite_requirements_next_call(
     title: str,
     requirement_text: str,
     package_resolution: dict[str, Any],
+    app_key: str,
+    update_only: bool,
     layout_style: str,
     publish: bool,
     run_label: str | None,
@@ -2014,17 +2335,93 @@ def _rewrite_requirements_next_call(
         title=title,
         requirement_text=requirement_text,
         package_resolution=package_resolution,
+        app_key=app_key,
+        update_only=update_only,
         layout_style=layout_style,
         publish=publish,
         run_label=run_label,
     )
 
 
-def _requirements_target(package_resolution: dict[str, Any]) -> dict[str, Any]:
+def _requirements_target(
+    package_resolution: dict[str, Any],
+    *,
+    app_key: str = "",
+    update_only: bool = False,
+) -> dict[str, Any]:
     tag_id = package_resolution.get("tag_id")
+    target: dict[str, Any] = {}
     if isinstance(tag_id, int) and tag_id > 0:
-        return {"package_tag_id": tag_id}
-    return {}
+        target["package_tag_id"] = tag_id
+    if isinstance(app_key, str) and app_key:
+        target["app_key"] = app_key
+    if update_only or target.get("app_key"):
+        target["mode"] = "update"
+        target["update_only"] = True
+    return target
+
+
+def _merge_app_target(
+    target: dict[str, Any] | None,
+    *,
+    app_key: str,
+    package_tag_id: int,
+    update_only: bool,
+) -> dict[str, Any]:
+    merged = deepcopy(target) if isinstance(target, dict) else {}
+    if isinstance(app_key, str) and app_key.strip():
+        merged["app_key"] = app_key.strip()
+    if isinstance(package_tag_id, int) and package_tag_id > 0:
+        merged["package_tag_id"] = package_tag_id
+    if update_only or merged.get("app_key"):
+        merged["mode"] = "update"
+        merged["update_only"] = True
+    return merged
+
+
+def _target_is_update_only(target: dict[str, Any]) -> bool:
+    if not target:
+        return False
+    if target.get("update_only") is True:
+        return True
+    mode = target.get("mode")
+    return isinstance(mode, str) and mode.strip().lower() == "update"
+
+
+def _resolve_target_app_keys(*, target: dict[str, Any], entity_ids: list[str]) -> dict[str, str]:
+    if not target:
+        return {}
+    resolved: dict[str, str] = {}
+    direct_app_key = target.get("app_key")
+    if isinstance(direct_app_key, str) and direct_app_key.strip():
+        if len(entity_ids) != 1:
+            raise ValueError("target.app_key requires a single-entity app stage; use target.app_keys for multiple entities")
+        resolved[entity_ids[0]] = direct_app_key.strip()
+    raw_mapping = target.get("app_keys")
+    if isinstance(raw_mapping, dict):
+        for entity_id, app_key in raw_mapping.items():
+            if not isinstance(entity_id, str) or entity_id not in entity_ids:
+                raise ValueError(f"target.app_keys contains unknown entity '{entity_id}'")
+            if not isinstance(app_key, str) or not app_key.strip():
+                raise ValueError(f"target.app_keys['{entity_id}'] must be a non-empty string")
+            resolved[entity_id] = app_key.strip()
+    return resolved
+
+
+def _seed_existing_app_artifacts(*, assembly: BuildAssemblyStore, existing_app_targets: dict[str, str]) -> None:
+    if not existing_app_targets:
+        return
+    artifacts = assembly.get_artifacts()
+    apps_artifact = artifacts.get("apps", {}) if isinstance(artifacts.get("apps"), dict) else {}
+    for entity_id, app_key in existing_app_targets.items():
+        existing = apps_artifact.get(entity_id, {}) if isinstance(apps_artifact.get(entity_id), dict) else {}
+        next_artifact = deepcopy(existing)
+        next_artifact["app_key"] = app_key
+        next_artifact["reused"] = True
+        next_artifact["target_mode"] = "update"
+        apps_artifact[entity_id] = next_artifact
+    artifacts["apps"] = apps_artifact
+    assembly.set_artifacts(artifacts)
 
 
 def _design_session_next_call(*, action: str, session_id: str | None) -> dict[str, Any] | None:
@@ -2076,6 +2473,7 @@ def _solution_schema_example_payload(
     tool_name, payload_key = _solution_schema_tool_metadata(stage)
     examples = _solution_schema_examples(stage)
     selected = deepcopy(examples.get(intent) or examples["minimal"])
+    call_example = _solution_schema_call_example(stage)
     response = {
         "status": "ok",
         "stage": stage,
@@ -2087,10 +2485,8 @@ def _solution_schema_example_payload(
         "optional_fields": _solution_schema_optional_fields(stage),
         "common_errors": _solution_schema_common_errors(stage),
         "notes": _solution_schema_notes(stage),
-        "suggested_next_call": {
-            "tool_name": tool_name,
-            "arguments": {"mode": "preflight"},
-        },
+        "call_example": call_example,
+        "suggested_next_call": deepcopy(call_example),
     }
     if include_selected_example:
         response["selected_example"] = selected
@@ -2102,6 +2498,7 @@ def _solution_schema_example_payload(
 def _solution_schema_tool_metadata(stage: str) -> tuple[str, str]:
     mapping = {
         "app": ("solution_build_app", "app_spec"),
+        "app_update": ("solution_build_app", "app_spec"),
         "flow": ("solution_build_flow", "flow_spec"),
         "views": ("solution_build_views", "views_spec"),
         "analytics_portal": ("solution_build_analytics_portal", "analytics_portal_spec"),
@@ -2112,9 +2509,18 @@ def _solution_schema_tool_metadata(stage: str) -> tuple[str, str]:
     return mapping[stage]
 
 
+def _solution_schema_call_example(stage: str) -> dict[str, Any]:
+    tool_name, _payload_key = _solution_schema_tool_metadata(stage)
+    arguments: dict[str, Any] = {"mode": "preflight"}
+    if stage == "app_update":
+        arguments.update({"app_key": "APP_123456", "update_only": True})
+    return {"tool_name": tool_name, "arguments": arguments}
+
+
 def _solution_schema_required_fields(stage: str) -> list[str]:
     fields = {
         "app": ["solution_name", "entities[].entity_id", "entities[].display_name", "entities[].kind", "entities[].fields[]"],
+        "app_update": ["solution_name", "entities[].entity_id", "entities[].display_name", "entities[].kind", "entities[].fields[]", "app_key"],
         "flow": ["entities[].entity_id", "entities[].workflow or entities[].lifecycle_stages"],
         "views": ["entities[].entity_id", "entities[].views[]"],
         "analytics_portal": ["entities[].entity_id or portal.sections[]"],
@@ -2128,6 +2534,7 @@ def _solution_schema_required_fields(stage: str) -> list[str]:
 def _solution_schema_optional_fields(stage: str) -> list[str]:
     fields = {
         "app": ["summary", "business_context", "package", "roles", "publish_policy", "preferences", "entities[].form_layout", "entities[].sample_records"],
+        "app_update": ["package_tag_id", "publish_policy", "preferences", "entities[].form_layout", "entities[].sample_records", "update_only"],
         "flow": ["solution_name", "roles", "publish_policy", "entities[].status_field_id", "entities[].owner_field_id", "entities[].start_field_id", "entities[].end_field_id"],
         "views": ["solution_name", "metadata"],
         "analytics_portal": ["solution_name", "publish_policy", "portal.name", "portal.sections[]"],
@@ -2145,6 +2552,11 @@ def _solution_schema_common_errors(stage: str) -> list[str]:
             "Each field_id must be unique within an entity.",
             "Do not include workflow/views/charts in app_spec. Use solution_build_flow or later stage tools.",
         ],
+        "app_update": [
+            "app_key is required for update mode and must point to an existing app.",
+            "Updating an app uses the same app_spec structure, but the tool target must stay in update mode.",
+            "Do not omit entity_id; updates still need a deterministic entity identity.",
+        ],
         "flow": [
             "The target entity must already exist in the build manifest or from a prior solution_build_app run.",
             "status_field_id must point to an existing field, usually 'status'.",
@@ -2177,6 +2589,10 @@ def _solution_schema_notes(stage: str) -> list[str]:
             "Use solution_build_app for package, entity, field, layout, and sample record design.",
             "If you are unsure, call solution_schema_example(stage='app', intent='minimal') before generating payloads.",
         ],
+        "app_update": [
+            "Use solution_build_app with app_key and update_only=true when modifying an existing app.",
+            "Update mode is not allowed to fall back to new package or new app creation.",
+        ],
         "flow": [
             "Use solution_build_flow only after app/schema exists.",
             "workflow.nodes uses node_type enum values like start, audit, fill, copy, branch, condition.",
@@ -2268,6 +2684,62 @@ def _solution_schema_examples(stage: str) -> dict[str, dict[str, Any]]:
                 ],
             },
         },
+        "app_update": {
+            "minimal": {
+                "solution_name": "Demo Workspace",
+                "entities": [
+                    {
+                        "entity_id": "demo_request",
+                        "display_name": "测试申请",
+                        "kind": "transaction",
+                        "title_field_id": "title",
+                        "fields": [
+                            {"field_id": "title", "label": "工单标题", "type": "text", "required": True},
+                        ],
+                        "form_layout": {"rows": [{"field_ids": ["title"]}]},
+                    }
+                ],
+            },
+            "full": {
+                "solution_name": "Demo Workspace",
+                "entities": [
+                    {
+                        "entity_id": "demo_request",
+                        "display_name": "测试申请",
+                        "kind": "transaction",
+                        "title_field_id": "title",
+                        "status_field_id": "status",
+                        "fields": [
+                            {"field_id": "title", "label": "工单标题", "type": "text", "required": True},
+                            {"field_id": "status", "label": "状态", "type": "single_select", "options": ["待处理", "处理中", "已完成"]},
+                            {"field_id": "priority", "label": "优先级", "type": "single_select", "options": ["P0", "P1", "P2"]},
+                        ],
+                        "form_layout": {
+                            "sections": [
+                                {"section_id": "basic", "title": "基础信息", "rows": [{"field_ids": ["title", "status"]}, {"field_ids": ["priority"]}]}
+                            ]
+                        },
+                    }
+                ],
+            },
+            "demo": {
+                "solution_name": "Demo Workspace",
+                "entities": [
+                    {
+                        "entity_id": "customer_order",
+                        "display_name": "客户订单",
+                        "kind": "transaction",
+                        "title_field_id": "title",
+                        "fields": [
+                            {"field_id": "title", "label": "订单标题", "type": "text", "required": True},
+                            {"field_id": "customer_name", "label": "客户名称", "type": "text"},
+                            {"field_id": "amount", "label": "订单金额", "type": "amount"},
+                        ],
+                        "form_layout": {"rows": [{"field_ids": ["title", "customer_name"]}, {"field_ids": ["amount"]}]},
+                    }
+                ],
+            },
+        },
         "flow": {
             "minimal": {
                 "solution_name": "Demo Workspace",
@@ -3054,6 +3526,15 @@ def _extract_navigation_items(items: list[Any]) -> list[dict[str, Any]]:
     return extracted
 
 
+def _resolve_app_stage_views_strategy(stage_result: dict[str, Any]) -> str:
+    verification = stage_result.get("verification")
+    if isinstance(verification, dict):
+        strategy = verification.get("views_strategy")
+        if isinstance(strategy, str) and strategy:
+            return strategy
+    return "not_included"
+
+
 def _resolve_target_package_tag_id(target: dict[str, Any]) -> int | None:
     if not target:
         return None
@@ -3069,12 +3550,18 @@ def _resolve_target_package_tag_id(target: dict[str, Any]) -> int | None:
 
 def _bind_existing_package_target(compiled: CompiledSolution, package_tag_id: int) -> CompiledSolution:
     compiled.package_payload = None
-    compiled.execution_plan = build_execution_plan(compiled.normalized_spec, include_package=False)
+    compiled.execution_plan = build_execution_plan(compiled.normalized_spec, include_package=False, attach_package=True)
     for entity in compiled.entities:
         entity.app_create_payload["tagIds"] = [package_tag_id]
     return compiled
 
 
+def _bind_existing_app_target(compiled: CompiledSolution) -> CompiledSolution:
+    compiled.package_payload = None
+    compiled.execution_plan = build_execution_plan(compiled.normalized_spec, include_package=False, attach_package=False)
+    return compiled
+
+
 def _merge_stage_manifest(*, stage_name: str, manifest: dict[str, Any], stage_payload: dict[str, Any]) -> dict[str, Any]:
     merged = deepcopy(manifest or default_manifest())
     if stage_name == "app_flow":
@@ -3226,6 +3713,7 @@ def _stage_step_names(
                     step.step_name.startswith(prefix)
                     for prefix in (
                         "app.create.",
+                        "package.attach.",
                         "form.base.",
                         "form.relations.",
                         "publish.form.",
@@ -3257,6 +3745,7 @@ def _stage_step_names(
                     step.step_name.startswith(prefix)
                     for prefix in (
                         "app.create.",
+                        "package.attach.",
                         "form.base.",
                         "form.relations.",
                         "workflow.",