@josephyan/qingflow-cli 1.0.11 → 1.1.2

package/src/qingflow_mcp/server_app_user.py

@@ -31,7 +31,7 @@ def build_user_server() -> FastMCP:
 
 ## App Discovery
 
-If `app_key` is unknown, use `app_list` or `app_search` first.
+If `app_key` is unknown, use `app_list` first. Pass `query` to filter visible apps by keyword.
 If the app is known but the data range is not, use `app_get` first and choose from `accessible_views`.
 If an accessible view has `analysis_supported=false`, do not use it for `record_access` or `record_list`. `boardView` and `ganttView` are special UI views, not data-access targets.
 `view_get(view_id=...)` also returns `export_capability`; it only means there is a supported export route, not that export permission has been verified.
@@ -47,9 +47,9 @@ If an accessible view has `analysis_supported=false`, do not use it for `record_
 ## Schema-First Rule
 
 Call `record_insert_schema_get` before `record_insert`.
-Call `record_update_schema_get` before `record_update`.
+For simple field changes after the target record is clear, call `record_update` directly. Use `record_update_schema_get` for diagnostics, ambiguous fields, or complex writable-scope inspection.
 Call `record_code_block_schema_get` before `record_code_block_run`.
-Call `app_get` first when the data range is unclear, then use `record_browse_schema_get(view_id=...)` before `record_access`, `record_list`, or `record_get`.
+Call `app_get` first when the data range is unclear, then use `record_browse_schema_get(view_id=...)` before `record_access`, `record_list`, `record_get`, or `record_logs_get`.
 Call `record_import_schema_get` when the import field mapping is unclear before template download or verify.
 
 - All `field_id` values must come from the schema response.
@@ -59,7 +59,7 @@ Call `record_import_schema_get` when the import field mapping is unclear before
 
 `record_insert_schema_get` returns the current user's insert-ready applicant schema; read `required_fields`, `optional_fields`, `runtime_linked_required_fields`, and `payload_template`.
 Inside `optional_fields`, any field with `may_become_required=true` is still writable, but may become required when linked visibility or option-driven runtime rules activate.
-`record_update_schema_get` returns the current record's overall update-ready writable field set across matched accessible views; read `writable_fields` and `payload_template`.
+`record_update_schema_get` returns the current record's overall update-ready writable field set and route diagnostics across matched accessible views; read `writable_fields`, `payload_template`, `available_update_routes`, and `recommended_update_route`.
 `record_browse_schema_get(view_id=...)` returns the same readable fields shown in the selected Qingflow table view header.
 `record_access.fields` / CSV columns and `record_list.columns / where / order_by / query_fields` use that exact same view schema; a missing field means it is not readable in that view.
 `searchQueIds` is a backend full-text search scope, not an output-column/projection mechanism.
@@ -102,9 +102,9 @@ Analysis answers must include concrete numbers. When applicable, include percent
 
 ## Record CRUD Path
 
-`app_get -> record_browse_schema_get(view_id=...) -> record_list / record_get`
-`record_insert_schema_get -> record_insert`
-`record_update_schema_get -> record_update`
+`app_get -> record_browse_schema_get(view_id=...) -> record_list / record_get / record_logs_get`
+`record_insert_schema_get -> record_insert(items)`
+`record_update` for simple updates; `record_update_schema_get -> record_update` when the writable field scope is unclear.
 `record_list / record_get -> record_delete`
 `record_code_block_schema_get -> record_code_block_run`
 `portal_list -> portal_get -> chart_get / view_get`
@@ -116,22 +116,25 @@ Analysis answers must include concrete numbers. When applicable, include percent
 - Use `order_by` items as `{{field_id, direction}}`
 - Legacy forms such as bare integer `field_id`, `fieldId`, `operator`, `values`, or `order` may still parse, but they are compatibility-only and not the canonical DSL
 
-- `record_insert` uses an applicant-node `fields` map keyed by field title.
-- `record_update` uses a field-title keyed `fields` map and internally selects the first accessible view that can execute the current payload.
+- `record_insert` defaults to an applicant-node `items` array; each item contains a field-title keyed `fields` map. A single insert is one item.
+- `record_update` uses a field-title keyed `fields` map. It first tries the data-manager direct update route, then falls back to the frontend custom-view detail edit route when the selected view can cover the payload; if a unique current-user todo task for the same record exposes editable fields, it can finally use the workflow save-only route. Read `update_route` and `tried_routes` after execution.
 - For insert, `runtime_linked_required_fields` means required-but-not-directly-writable fields that are usually supplied by runtime linkage or upstream context.
 - For insert, fields marked `may_become_required=true` stay in `optional_fields`; they are still directly writable, but linked visibility or option-driven rules can make them required at runtime.
 - Read field-level `linkage` whenever present on `record_insert_schema_get` or `record_update_schema_get`; it is the static hint for linked visibility, reference-driven auto fill, and formula/default auto-fill behavior.
 - `linkage.sources` lists upstream field titles that influence the current field; `linkage.affects_fields` lists downstream fields that may change when the current field changes.
 - `linkage.kind=logic_visibility` means linked visibility or option-driven rules are involved; `linkage.kind=reference_fill` means reference/default matching logic is involved; `linkage.kind=formula_fill` means formula/default auto-fill logic is involved.
-- `record_update_schema_get` exposes the overall writable field set for the record, but not every field combination is guaranteed; `record_update` still needs one single matched accessible view that can cover the payload.
+- `record_update_schema_get` exposes the overall writable field set and update route candidates for the record, but not every field combination is guaranteed; `record_update` still needs data-manager permission, one single matched custom view that can cover the payload, or one unique editable current-user todo task.
 - `record_delete` deletes by `record_id` or `record_ids`.
 - `record_get` is the single-record frontend detail context tool. It returns detail-page visible fields, one-level relation targets, first-page data/workflow logs, associated views/reports, local readable image assets, local downloadable file assets, unavailable context, and `semantic_context`.
+- Use `record_logs_get` only when the user needs the full visible data/workflow log history for a specific record. It writes JSONL files locally and returns file paths plus completeness metadata; do not expect full log arrays in the response.
 - Read record images from `record_get.media_assets.items[].local_path` when `readable_by_agent=true`; read attachments/documents/tables from `record_get.file_assets.items[].local_path` and `extraction.text_path` when present. `record_get` follows the frontend storage cookie redirect path for Qingflow attachments, and remote file URLs should not be treated as directly readable.
 - `record_get.columns` are focus hints only; they do not project the detail fields. Read facts from top-level `fields[]`.
 - When readback shape matters after insert or update, prefer `record_get` for human/detail-page context, or `record_list(..., output_profile="normalized")` for batch-shaped normalized rows.
 
 - Read relation targets from `record_insert_schema_get` / `record_update_schema_get` relation metadata before preparing relation writes.
-- Member and department fields may be written with natural strings directly on `record_insert` / `record_update`; only fall back to `record_member_candidates` or `record_department_candidates` when the user wants explicit candidate browsing or the write returns ambiguity that needs confirmation.
+- Member, department, and relation fields may be written with natural strings directly on `record_insert` / `record_update`; only fall back to candidate tools when the user wants explicit candidate browsing or the write returns ambiguity that needs confirmation.
+- CLI-only agents can use `qingflow record member-candidates --app-key APP_KEY --field-id FIELD_ID --keyword NAME --json` or `qingflow record department-candidates --app-key APP_KEY --field-id FIELD_ID --keyword DEPT --json` for that fallback.
+- For batch insert `partial_success`, read `created_record_ids`, failed `items[].row_number`, and `failed_fields`; repair only failed rows and never retry the whole batch after any row has `write_executed=true`.
 - When candidate browsing must match a real update/write scope, pass `record_id`, `workflow_node_id`, and any pending `fields` context to the candidate tool; otherwise the candidate result is only a static applicant-node preview.
 - If explicit candidate browsing is needed for default-all member or department fields, prefer those field candidate tools instead of starting with `directory_*`.
 
@@ -188,7 +191,7 @@ Use export only when the user explicitly asks to export/download/generate an Exc
 - `task_action_execute(task_id=..., action=...)` is also supported; MCP resolves the current todo locator internally before calling the real action route.
 - `task_workflow_log_get(task_id=...)` and `task_associated_report_detail_get(task_id=...)` are also supported for the current todo context.
 - Use `task_associated_report_detail_get` for associated view or report details.
-- Use `task_workflow_log_get` for full workflow log history.
+- Use `task_workflow_log_get` for the current task context workflow log page. For full record-level data/workflow logs, use `record_logs_get(app_key, record_id, view_id?)`.
 - Task actions operate on `app_key + record_id + workflow_node_id`, not `task_id`.
 - Treat `task_action_execute` as the tool-level action enum surface; the current task's real actions are only the ones listed in `task_get.capabilities.available_actions`.
 - Use `task_action_execute(action="save_only", fields=...)` when the user wants to save editable field changes on the current node without advancing the workflow.
@@ -358,12 +361,8 @@ If the current MCP capability is unsupported, the workflow is awkward, or the us
         )
 
     @server.tool()
-    def app_list(profile: str = DEFAULT_PROFILE) -> dict:
-        return apps.app_list(profile=profile)
-
-    @server.tool()
-    def app_search(profile: str = DEFAULT_PROFILE, keyword: str = "", page_num: int = 1, page_size: int = 50) -> dict:
-        return apps.app_search(profile=profile, keyword=keyword, page_num=page_num, page_size=page_size)
+    def app_list(profile: str = DEFAULT_PROFILE, query: str = "", keyword: str = "") -> dict:
+        return apps.app_list(profile=profile, query=query, keyword=keyword)
 
     @server.tool()
     def app_get(profile: str = DEFAULT_PROFILE, app_key: str = "") -> dict:

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

@@ -10,8 +10,6 @@ from .navigation_compiler import compile_navigation
 from .package_compiler import compile_package
 from .portal_compiler import compile_portal
 from .view_compiler import compile_views
-from .workflow_compiler import compile_workflow
-
 
 @dataclass(slots=True)
 class ExecutionStep:
@@ -101,7 +99,7 @@ def compile_solution(spec: SolutionSpec) -> CompiledSolution:
 
 def compile_entity(entity: EntitySpec, *, include_package: bool) -> CompiledEntity:
     app_create_payload, form_base_payload, form_relation_payload, field_specs, field_labels = compile_entity_form(entity, include_package=include_package)
-    workflow_plan = compile_workflow(entity)
+    workflow_plan = None
     view_plans = compile_views(entity)
     chart_plans = compile_charts(entity)
     return CompiledEntity(

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

@@ -5,6 +5,215 @@ import re
 
 
 DEFAULT_ICON_COLOR = "qing-orange"
+WORKSPACE_ICON_COLORS: tuple[str, ...] = (
+    "qing-orange",
+    "yellow",
+    "green",
+    "emerald",
+    "blue",
+    "azure",
+    "indigo",
+    "qing-purple",
+    "purple",
+    "pink",
+    "red",
+    "orange",
+)
+WORKSPACE_ICON_NAMES: tuple[str, ...] = (
+    "user",
+    "user-group",
+    "user-remove",
+    "user-add",
+    "user-circle",
+    "base-camera",
+    "view-grid",
+    "inbox",
+    "inbox-in",
+    "share",
+    "sitemap",
+    "airplane",
+    "template",
+    "music-note",
+    "movie-play",
+    "clock",
+    "document",
+    "document-search",
+    "clipboard-check",
+    "document-download",
+    "document-text",
+    "clipboard-copy",
+    "presentation-chart-bar",
+    "chart-square-bar",
+    "database",
+    "server",
+    "calendar",
+    "mail",
+    "annotation",
+    "chat",
+    "bell",
+    "key",
+    "shopping-bag",
+    "download",
+    "eye",
+    "eye-off",
+    "emoji-happy",
+    "emoji-sad",
+    "sun",
+    "moon",
+    "cloud",
+    "lightning-bolt",
+    "fire",
+    "star",
+    "sparkles",
+    "heart",
+    "cake",
+    "gift",
+    "light-bulb",
+    "exclamation",
+    "cog",
+    "thumb-up",
+    "thumb-down",
+    "cloud-download",
+    "cloud-upload",
+    "printer",
+    "phone-incoming",
+    "phone-missed-call",
+    "terminal",
+    "search-circle",
+    "x-circle",
+    "check-circle",
+    "exclamation-circle",
+    "question-mark-circle",
+    "information-circle",
+    "academic-cap",
+    "briefcase",
+    "home",
+    "phone",
+    "photograph",
+    "puzzle",
+    "color-swatch",
+    "lock-open",
+    "lock-closed",
+    "shield-check",
+    "shield-exclamation",
+    "currency-dollar",
+    "currency-yen",
+    "globe",
+    "at-symbol",
+    "slack",
+    "microphone",
+    "speakerphone",
+    "trash",
+    "book-open",
+    "truck",
+    "filter",
+    "essetional-filter-search",
+    "essetional-filter-tick",
+    "table",
+    "calculator",
+    "location-radar",
+    "essetional-weight",
+    "school-award",
+    "comp-cloud-connection",
+    "comp-cloud-remove",
+    "comp-cpu-charge",
+    "comp-cpu-setting",
+    "comp-cpu",
+    "comp-devices",
+    "comp-driver-2",
+    "comp-driver-refresh",
+    "location-global",
+    "location-location",
+    "location-map",
+    "location-gps",
+    "essetional-ranking",
+    "chart-bar",
+    "business-graph",
+    "business-status-up",
+    "business-trend-down",
+    "business-trend-up",
+    "business-presention-chart",
+    "business-favorite-chart",
+    "business-health",
+    "receipt-refund",
+    "receipt-tax",
+    "money-receipt-2-1",
+    "money-transaction-minus",
+    "action-hourglass-full",
+    "action-work",
+    "bug-f",
+    "essetional-pet",
+    "files-folder",
+    "badge-check",
+    "money-wallet-1",
+    "money-ticket",
+    "money-money",
+    "money-tag",
+    "money-wallet-2",
+    "business-personalcard",
+    "car-airplane",
+    "car-bus",
+    "car-car",
+    "car-driving",
+    "car-gas-station",
+    "car-smart-car",
+    "car-ship",
+    "location-map-1",
+    "location-route-square",
+    "cone",
+    "design-brush-4",
+    "paint-roll",
+    "wrench-f",
+    "essetional-reserve",
+    "essetional-broom",
+    "design-brush-2",
+    "essetional-judge",
+    "design-bucket",
+    "palette",
+    "comp-electricity",
+    "vial",
+    "beaker",
+    "leaf-f",
+    "cursor-click",
+    "solid-search-alt-2",
+    "md-library",
+    "building-3",
+    "office-building",
+    "building-hospital",
+    "school",
+    "store",
+    "video-camera-vintage-f",
+    "comp-monitor",
+    "delivery-truck",
+    "delivery-box-1",
+    "delivery-box-add",
+    "delivery-box-remove",
+    "settings-setting-3",
+    "document-duplicate",
+    "essetional-flag-2",
+    "flag",
+    "icon-currency-dollar",
+    "clipboard-list",
+    "save-as",
+    "wifi",
+    "status-online",
+    "scissors",
+    "globe-alt",
+    "ban",
+    "finger-print",
+    "qrcode",
+    "paper-clip",
+    "translate",
+    "cube-transparent",
+    "variable",
+    "switch-vertical",
+    "sports-baseball",
+    "sports-basketball",
+    "sports-soccer",
+    "sports-football",
+    "sports-volleyball",
+)
+GENERIC_WORKSPACE_ICON_NAMES: tuple[str, ...] = ("template",)
 DEFAULT_ICON_STYLE_POOL: tuple[tuple[str, str], ...] = (
     ("briefcase", "qing-orange"),
     ("calendar", "emerald"),
@@ -115,6 +324,91 @@ def parse_workspace_icon(value: str | None) -> tuple[str | None, str | None, str
     return normalize_workspace_icon_name(stripped), None, None
 
 
+def workspace_icon_config(value: str | None) -> dict[str, str | None]:
+    icon_name, icon_color, icon_text = parse_workspace_icon(value)
+    raw = str(value).strip() if value not in (None, "") else None
+    return {
+        "icon_name": icon_name,
+        "icon_color": icon_color,
+        "icon_text": icon_text,
+        "raw": raw,
+    }
+
+
+def workspace_icon_catalog_payload() -> dict[str, object]:
+    return {
+        "icon_names": list(WORKSPACE_ICON_NAMES),
+        "icon_colors": list(WORKSPACE_ICON_COLORS),
+        "generic_icon_names": list(GENERIC_WORKSPACE_ICON_NAMES),
+        "notes": [
+            "Use explicit icon + color for app/package/portal creation.",
+            "Do not use template for newly created workspace resources.",
+            "The CLI validates candidates only; it does not infer an icon from business names.",
+        ],
+        "common_examples": {
+            "employee": ["business-personalcard", "user-group", "user"],
+            "task": ["clipboard-check", "action-work"],
+            "worklog": ["clock", "action-hourglass-full"],
+            "order": ["delivery-box-1", "shopping-bag"],
+            "payment": ["money-receipt-2-1", "money-wallet-1"],
+            "opportunity": ["business-graph", "business-trend-up"],
+            "dashboard": ["view-grid", "chart-square-bar", "presentation-chart-bar"],
+        },
+    }
+
+
+def validate_workspace_icon_choice(
+    *,
+    icon: str | None,
+    color: str | None,
+    require_explicit: bool,
+    disallow_generic: bool,
+) -> tuple[bool, str | None, str | None, dict[str, object]]:
+    normalized_icon = _normalize_workspace_icon_candidate(icon)
+    normalized_color = str(color or "").strip() or None
+    details: dict[str, object] = {
+        "icon": icon,
+        "normalized_icon": normalized_icon,
+        "color": color,
+        "icon_catalog_command": "qingflow --json builder icon catalog",
+    }
+    if require_explicit and not normalized_icon:
+        return False, "WORKSPACE_ICON_REQUIRED", "icon is required when creating a workspace resource", details
+    if require_explicit and not normalized_color:
+        return False, "WORKSPACE_ICON_COLOR_REQUIRED", "color is required when creating a workspace resource", details
+    if normalized_icon and normalized_icon not in WORKSPACE_ICON_NAMES:
+        details["allowed_icon_names"] = list(WORKSPACE_ICON_NAMES)
+        return False, "WORKSPACE_ICON_NOT_FOUND", "icon is not in the workspace icon catalog", details
+    if normalized_color and normalized_color not in WORKSPACE_ICON_COLORS:
+        details["allowed_icon_colors"] = list(WORKSPACE_ICON_COLORS)
+        return False, "WORKSPACE_ICON_COLOR_NOT_FOUND", "color is not in the workspace icon color catalog", details
+    if disallow_generic and normalized_icon in GENERIC_WORKSPACE_ICON_NAMES:
+        details["generic_icon_names"] = list(GENERIC_WORKSPACE_ICON_NAMES)
+        return False, "GENERIC_WORKSPACE_ICON_NOT_ALLOWED", "template is a generic icon and is not allowed for new workspace resources", details
+    return True, None, None, details
+
+
+def _normalize_workspace_icon_candidate(icon: str | None) -> str | None:
+    if not icon:
+        return None
+    raw = str(icon).strip()
+    if not raw:
+        return None
+    if _looks_like_icon_json(raw):
+        try:
+            payload = json.loads(raw)
+        except Exception:
+            return None
+        return _normalize_workspace_icon_candidate(payload.get("iconName"))
+    normalized = raw.lower()
+    if normalized in WORKSPACE_ICON_NAMES:
+        return normalized
+    legacy = LEGACY_EX_ICON_MAP.get(normalized)
+    if legacy in WORKSPACE_ICON_NAMES:
+        return legacy
+    return normalized
+
+
 def encode_workspace_icon_with_defaults(
     *,
     icon: str | None,

package/src/qingflow_mcp/solution/executor.py

@@ -14,7 +14,6 @@ from ..tools.qingbi_report_tools import QingbiReportTools
 from ..tools.record_tools import RecordTools
 from ..tools.role_tools import RoleTools
 from ..tools.view_tools import ViewTools
-from ..tools.workflow_tools import WorkflowTools
 from ..tools.workspace_tools import WorkspaceTools
 from .compiler import CompiledEntity, CompiledRole, CompiledSolution
 from .compiler.form_compiler import QUESTION_TYPE_MAP
@@ -36,7 +35,6 @@ class SolutionExecutor:
         role_tools: RoleTools,
         app_tools: AppTools,
         record_tools: RecordTools,
-        workflow_tools: WorkflowTools,
         view_tools: ViewTools,
         chart_tools: QingbiReportTools,
         portal_tools: PortalTools,
@@ -47,7 +45,6 @@ class SolutionExecutor:
         self.role_tools = role_tools
         self.app_tools = app_tools
         self.record_tools = record_tools
-        self.workflow_tools = workflow_tools
         self.view_tools = view_tools
         self.chart_tools = chart_tools
         self.portal_tools = portal_tools
@@ -419,123 +416,10 @@ class SolutionExecutor:
     def _build_workflow(self, profile: str, entity: CompiledEntity, store: RunArtifactStore) -> None:
         if entity.workflow_plan is None:
             return
-        app_key = self._get_app_key(store, entity.entity_id)
-        workflow_edit_version_no = self._ensure_edit_version(
-            profile,
-            entity.entity_id,
-            store,
-            app_key=app_key,
-            force_new=True,
-        )
-        node_artifacts = store.get_artifact("apps", entity.entity_id, {}).get("workflow_nodes", {})
-        existing_nodes = self.workflow_tools.workflow_list_nodes(profile=profile, app_key=app_key).get("result") or {}
-        current_nodes = _coerce_workflow_nodes(existing_nodes)
-        existing_nodes_by_name = {
-            node.get("auditNodeName"): int(node_id)
-            for node_id, node in current_nodes.items()
-            if isinstance(node, dict) and node.get("auditNodeName")
-        }
-        applicant_node_id = next(
-            (
-                int(node_id)
-                for node_id, node in current_nodes.items()
-                if isinstance(node, dict) and node.get("type") == 0 and node.get("dealType") == 3
-            ),
-            None,
+        raise RuntimeError(
+            "Legacy auditNode workflow execution was removed. "
+            "Pass {app_key, spec} to solution_build_flow or use qingflow builder flow apply."
         )
-        if applicant_node_id is not None:
-            node_artifacts.setdefault("__applicant__", applicant_node_id)
-
-        desired_global_settings = deepcopy(entity.workflow_plan["global_settings"])
-        explicit_global_settings = _has_explicit_workflow_global_settings(desired_global_settings)
-        current_global_settings: dict[str, Any] = {}
-        if explicit_global_settings:
-            current_global_settings = self.workflow_tools.workflow_get_global_settings(profile=profile, app_key=app_key).get("result") or {}
-        else:
-            try:
-                current_global_settings = self.workflow_tools.workflow_get_global_settings(profile=profile, app_key=app_key).get("result") or {}
-            except (QingflowApiError, RuntimeError) as error:
-                api_error = QingflowApiError(**_coerce_nested_error_payload(error))
-                if api_error.http_status != 404:
-                    raise
-                current_global_settings = {}
-        if explicit_global_settings:
-            global_settings = deepcopy(current_global_settings if isinstance(current_global_settings, dict) else {})
-            global_settings.update(desired_global_settings)
-            global_settings["editVersionNo"] = workflow_edit_version_no or global_settings.get("editVersionNo") or 1
-            self.workflow_tools.workflow_update_global_settings(profile=profile, app_key=app_key, payload=global_settings)
-        for action in entity.workflow_plan["actions"]:
-            if action["action"] == "create_sub_branch" and node_artifacts.get(action["node_id"]) is not None:
-                continue
-            if action["action"] == "add_node":
-                if action.get("node_type") == "branch":
-                    existing_branch_id = node_artifacts.get(action["node_id"])
-                    if existing_branch_id is not None and not _workflow_node_is_branch(current_nodes, existing_branch_id):
-                        existing_branch_id = None
-                    if existing_branch_id is not None:
-                        for branch_index, lane_id in enumerate(_find_branch_lane_ids(current_nodes, existing_branch_id), start=1):
-                            node_artifacts[_branch_lane_ref(action["node_id"], branch_index)] = lane_id
-                        apps_artifact = store.get_artifact("apps", entity.entity_id, {})
-                        apps_artifact["workflow_nodes"] = node_artifacts
-                        store.set_artifact("apps", entity.entity_id, apps_artifact)
-                        continue
-                existing_node_id = node_artifacts.get(action["node_id"]) or existing_nodes_by_name.get(action.get("node_name"))
-                if existing_node_id is not None:
-                    node_artifacts[action["node_id"]] = existing_node_id
-                    apps_artifact = store.get_artifact("apps", entity.entity_id, {})
-                    apps_artifact["workflow_nodes"] = node_artifacts
-                    store.set_artifact("apps", entity.entity_id, apps_artifact)
-                    continue
-            before_node_ids = set(current_nodes)
-            payload = self._resolve_workflow_payload(action["payload"], node_artifacts)
-            if workflow_edit_version_no is not None:
-                payload["editVersionNo"] = int(workflow_edit_version_no)
-            if action["action"] == "create_sub_branch":
-                result = self.workflow_tools.workflow_create_sub_branch(profile=profile, app_key=app_key, payload=payload)
-            elif action["action"] == "update_node":
-                target_node_id = node_artifacts.get(action["node_id"])
-                if target_node_id is None:
-                    raise RuntimeError(f"workflow lane '{action['node_id']}' could not be resolved before update")
-                result = self.workflow_tools.workflow_update_node(
-                    profile=profile,
-                    app_key=app_key,
-                    audit_node_id=target_node_id,
-                    payload=payload,
-                )
-            else:
-                result = self.workflow_tools.workflow_add_node(profile=profile, app_key=app_key, payload=payload)
-            expected_type = 1 if action.get("node_type") == "branch" else None
-            audit_node_id = _extract_workflow_node_id(result.get("result"), expected_type=expected_type)
-            if action.get("node_type") == "branch" or action["action"] == "create_sub_branch":
-                current_nodes = _coerce_workflow_nodes(
-                    self.workflow_tools.workflow_list_nodes(profile=profile, app_key=app_key).get("result") or {}
-                )
-            if audit_node_id is not None:
-                node_artifacts[action["node_id"]] = audit_node_id
-            if action.get("node_type") == "branch":
-                branch_node_id = node_artifacts.get(action["node_id"]) or _find_created_branch_node_id(
-                    current_nodes,
-                    before_node_ids=before_node_ids,
-                    prev_id=payload.get("prevId"),
-                )
-                if branch_node_id is not None:
-                    node_artifacts[action["node_id"]] = branch_node_id
-                for branch_index, lane_id in enumerate(_find_branch_lane_ids(current_nodes, branch_node_id), start=1):
-                    node_artifacts[_branch_lane_ref(action["node_id"], branch_index)] = lane_id
-            if action["action"] == "create_sub_branch" and node_artifacts.get(action["node_id"]) is None:
-                created_lane_id = audit_node_id or _find_created_sub_branch_lane_id(
-                    current_nodes,
-                    before_node_ids=before_node_ids,
-                    branch_node_id=payload.get("auditNodeId"),
-                )
-                if created_lane_id is not None:
-                    node_artifacts[action["node_id"]] = created_lane_id
-                apps_artifact = store.get_artifact("apps", entity.entity_id, {})
-                apps_artifact["workflow_nodes"] = node_artifacts
-                store.set_artifact("apps", entity.entity_id, apps_artifact)
-        apps_artifact = store.get_artifact("apps", entity.entity_id, {})
-        apps_artifact["workflow_nodes"] = node_artifacts
-        store.set_artifact("apps", entity.entity_id, apps_artifact)
 
     def _build_views(self, profile: str, entity: CompiledEntity, store: RunArtifactStore) -> None:
         app_key = self._get_app_key(store, entity.entity_id)
@@ -2097,20 +1981,6 @@ def _find_created_sub_branch_lane_id(
     return candidates[0] if candidates else None
 
 
-def _has_explicit_workflow_global_settings(global_settings: dict[str, Any] | None) -> bool:
-    if not isinstance(global_settings, dict):
-        return False
-    for key, value in global_settings.items():
-        if key == "editVersionNo":
-            continue
-        if value is None:
-            continue
-        if isinstance(value, (list, dict)) and not value:
-            continue
-        return True
-    return False
-
-
 def _is_navigation_plugin_unavailable(error: QingflowApiError) -> bool:
     try:
         backend_code = int(error.backend_code)