@josephyan/qingflow-cli 0.2.0-beta.75 → 0.2.0-beta.77

package/README.md

@@ -3,13 +3,13 @@
 Install:
 
 ```bash
-npm install @josephyan/qingflow-cli@0.2.0-beta.75
+npm install @josephyan/qingflow-cli@0.2.0-beta.77
 ```
 
 Run:
 
 ```bash
-npx -y -p @josephyan/qingflow-cli@0.2.0-beta.75 qingflow
+npx -y -p @josephyan/qingflow-cli@0.2.0-beta.77 qingflow
 ```
 
 Environment:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-cli",
-  "version": "0.2.0-beta.75",
+  "version": "0.2.0-beta.77",
   "description": "Human-friendly Qingflow command line interface for auth, record operations, import, tasks, and stable builder flows.",
   "license": "MIT",
   "type": "module",

package/pyproject.toml

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

package/src/qingflow_mcp/builder_facade/service.py

@@ -3530,6 +3530,12 @@ class AiBuilderFacade:
             app_name=str(resolved["app_name"]),
             tag_ids=_coerce_int_list(resolved.get("tag_ids")),
         )
+        requested_app_name = str(app_name or "").strip() or None
+        requested_rename = requested_app_name if app_key else None
+        requested_icon = str(icon or "").strip() or None
+        requested_color = str(color or "").strip() or None
+        requested_app_base_update = bool(requested_rename or requested_icon or requested_color)
+        effective_app_name = target.app_name
         if not bool(resolved.get("created")):
             permission_outcome = self._guard_app_permission(
                 profile=profile,
@@ -3540,21 +3546,35 @@ class AiBuilderFacade:
             if permission_outcome.block is not None:
                 return permission_outcome.block
             permission_outcomes.append(permission_outcome)
-            visual_result = self._ensure_app_base_visuals(
-                profile=profile,
-                app_key=target.app_key,
-                fallback_title=target.app_name,
-                icon=icon,
-                color=color,
-                normalized_args=normalized_args,
-            )
-            if visual_result.get("status") == "failed":
-                return finalize(visual_result)
+            if requested_app_base_update:
+                visual_result = self._ensure_app_base_visuals(
+                    profile=profile,
+                    app_key=target.app_key,
+                    fallback_title=target.app_name,
+                    app_name=requested_rename,
+                    icon=requested_icon,
+                    color=requested_color,
+                    normalized_args=normalized_args,
+                )
+                if visual_result.get("status") == "failed":
+                    return finalize(visual_result)
+                effective_app_name = str(visual_result.get("app_name_after") or target.app_name).strip() or target.app_name
+            else:
+                visual_result = {
+                    "status": "success",
+                    "updated": False,
+                    "app_icon": None,
+                    "app_name_before": target.app_name,
+                    "app_name_after": target.app_name,
+                    "request_id": None,
+                }
         else:
             visual_result = {
                 "status": "success",
                 "updated": False,
                 "app_icon": str(resolved.get("app_icon") or "").strip() or None,
+                "app_name_before": target.app_name,
+                "app_name_after": target.app_name,
                 "request_id": None,
             }
         if bool(resolved.get("created")) and not requested_field_changes:
@@ -3576,10 +3596,14 @@ class AiBuilderFacade:
                     "package_attached": None if package_tag_id is None else package_tag_id in target.tag_ids,
                     "relation_field_limit_verified": True,
                     "app_visuals_verified": True,
+                    "app_base_verified": True,
                     "publish_skipped": True,
                 },
                 "app_key": target.app_key,
                 "app_icon": str(resolved.get("app_icon") or visual_result.get("app_icon") or "").strip() or None,
+                "app_name_before": str(visual_result.get("app_name_before") or target.app_name),
+                "app_name_after": str(visual_result.get("app_name_after") or target.app_name),
+                "app_base_updated": bool(visual_result.get("updated")),
                 "created": True,
                 "field_diff": {"added": [], "updated": [], "removed": []},
                 "verified": True,
@@ -3602,7 +3626,7 @@ class AiBuilderFacade:
                     details=_with_state_read_blocked_details({"app_key": target.app_key}, resource="schema", error=api_error),
                     suggested_next_call={"tool_name": "app_get", "arguments": {"profile": profile, "app_key": target.app_key}},
                 ))
-            schema_result = _empty_schema_result(target.app_name)
+            schema_result = _empty_schema_result(effective_app_name)
             _schema_source = "synthetic_new_app"
             schema_readback_delayed = True
         parsed = _parse_schema(schema_result)
@@ -3759,13 +3783,19 @@ class AiBuilderFacade:
         )
 
         if not added and not updated and not removed and not normalized_code_block_fields and not bool(resolved.get("created")):
-            tag_ids_after = _coerce_int_list((self.apps.app_get_base(profile=profile, app_key=target.app_key, include_raw=True).get("result") or {}).get("tagIds"))
+            base_info = self.apps.app_get_base(profile=profile, app_key=target.app_key, include_raw=True).get("result") or {}
+            tag_ids_after = _coerce_int_list(base_info.get("tagIds"))
             package_attached = None if package_tag_id is None else package_tag_id in tag_ids_after
+            actual_app_name = str(base_info.get("formTitle") or effective_app_name).strip() or effective_app_name
+            actual_app_icon = str(base_info.get("appIcon") or visual_result.get("app_icon") or "").strip() or None
+            expected_app_icon = str(visual_result.get("app_icon") or "").strip() or None
+            app_base_verified = actual_app_name == effective_app_name and actual_app_icon == expected_app_icon
+            verified = app_base_verified and relation_target_metadata_verified
             response = {
-                "status": "success",
-                "error_code": None,
-                "recoverable": False,
-                "message": "updated app visuals; schema already matches requested state" if bool(visual_result.get("updated")) else "schema already matches requested state",
+                "status": "success" if verified else "partial_success",
+                "error_code": None if verified else "APP_BASE_READBACK_PENDING",
+                "recoverable": not verified,
+                "message": "updated app base metadata; schema already matches requested state" if bool(visual_result.get("updated")) else "schema already matches requested state",
                 "normalized_args": normalized_args,
                 "missing_fields": [],
                 "allowed_values": {"field_types": [item.value for item in PublicFieldType]},
@@ -3777,14 +3807,18 @@ class AiBuilderFacade:
                 "verification": {
                     "fields_verified": True,
                     "relation_field_limit_verified": relation_limit_verified,
-                    "app_visuals_verified": True,
+                    "app_visuals_verified": app_base_verified,
+                    "app_base_verified": app_base_verified,
                     "relation_target_metadata_verified": relation_target_metadata_verified,
                 },
                 "app_key": target.app_key,
                 "app_icon": str(visual_result.get("app_icon") or "").strip() or None,
+                "app_name_before": str(visual_result.get("app_name_before") or target.app_name),
+                "app_name_after": effective_app_name,
+                "app_base_updated": bool(visual_result.get("updated")),
                 "created": False,
                 "field_diff": {"added": [], "updated": [], "removed": []},
-                "verified": True,
+                "verified": verified,
                 "tag_ids_after": tag_ids_after,
                 "package_attached": package_attached,
             }
@@ -3796,7 +3830,7 @@ class AiBuilderFacade:
             return finalize(self._append_publish_result(profile=profile, app_key=target.app_key, publish=publish, response=response))
 
         payload = _build_form_payload_from_fields(
-            title=schema_result.get("formTitle") or target.app_name,
+            title=effective_app_name,
             current_schema=schema_result,
             fields=current_fields,
             layout=layout,
@@ -3904,7 +3938,7 @@ class AiBuilderFacade:
                     suggested_next_call={"tool_name": "app_get_fields", "arguments": {"profile": profile, "app_key": target.app_key}},
                 )
             rebound_payload = _build_form_payload_from_fields(
-                title=rebound_schema.get("formTitle") or target.app_name,
+                title=effective_app_name,
                 current_schema=rebound_schema,
                 fields=rebound_fields,
                 layout=rebound_layout,
@@ -3948,11 +3982,15 @@ class AiBuilderFacade:
                 "fields_verified": False,
                 "package_attached": None,
                 "app_visuals_verified": True,
+                "app_base_verified": True,
                 "relation_field_limit_verified": relation_limit_verified,
                 "relation_target_metadata_verified": relation_target_metadata_verified,
             },
             "app_key": target.app_key,
             "app_icon": str(visual_result.get("app_icon") or resolved.get("app_icon") or "").strip() or None,
+            "app_name_before": str(visual_result.get("app_name_before") or target.app_name),
+            "app_name_after": effective_app_name,
+            "app_base_updated": bool(visual_result.get("updated")),
             "created": bool(resolved.get("created")),
             "field_diff": {
                 "added": added,
@@ -3999,16 +4037,23 @@ class AiBuilderFacade:
             base_info = self.apps.app_get_base(profile=profile, app_key=target.app_key, include_raw=True).get("result") or {}
             tag_ids_after = _coerce_int_list(base_info.get("tagIds"))
             package_attached = None if package_tag_id is None else package_tag_id in tag_ids_after
+            actual_app_name = str(base_info.get("formTitle") or effective_app_name).strip() or effective_app_name
+            actual_app_icon = str(base_info.get("appIcon") or visual_result.get("app_icon") or "").strip() or None
+            expected_app_icon = str(visual_result.get("app_icon") or "").strip() or None
+            app_base_verified = actual_app_name == effective_app_name and actual_app_icon == expected_app_icon
         except (QingflowApiError, RuntimeError) as error:
             base_error = _coerce_api_error(error)
             if verification_error is None:
                 verification_error = base_error
             tag_ids_after = []
             package_attached = None if package_tag_id is None else False
+            app_base_verified = False
         response["verification"]["fields_verified"] = verification_ok
         response["verification"]["package_attached"] = package_attached
+        response["verification"]["app_visuals_verified"] = app_base_verified
+        response["verification"]["app_base_verified"] = app_base_verified
         response["verification"]["relation_field_limit_verified"] = relation_limit_verified
-        response["verified"] = verification_ok
+        response["verified"] = verification_ok and app_base_verified
         response["tag_ids_after"] = tag_ids_after
         response["package_attached"] = package_attached
         if package_attached is False:
@@ -4018,14 +4063,18 @@ class AiBuilderFacade:
                     "profile": profile,
                     "tag_id": package_tag_id,
                     "app_key": target.app_key,
-                    "app_title": app_name or target.app_name,
+                    "app_title": effective_app_name,
                 },
             }
         publish_failed = bool(response.get("publish_requested")) and not bool(response.get("published"))
-        if verification_ok and package_attached is not False and not publish_failed:
+        if verification_ok and app_base_verified and package_attached is not False and not publish_failed:
             response["status"] = "success"
         else:
             response["status"] = "partial_success"
+        if not app_base_verified and verification_error is None:
+            response["recoverable"] = True
+            response["error_code"] = response.get("error_code") or "APP_BASE_READBACK_PENDING"
+            response["message"] = f"{response.get('message') or 'apply succeeded'}; app base readback pending"
         if verification_error is not None:
             response["recoverable"] = True
             response["error_code"] = response.get("error_code") or (
@@ -6535,17 +6584,11 @@ class AiBuilderFacade:
         profile: str,
         app_key: str,
         fallback_title: str,
+        app_name: str | None,
         icon: str | None,
         color: str | None,
         normalized_args: dict[str, Any],
     ) -> JSONObject:
-        if not icon and not color:
-            return {
-                "status": "success",
-                "updated": False,
-                "app_icon": None,
-                "request_id": None,
-            }
         try:
             base_result = self.apps.app_get_base(profile=profile, app_key=app_key, include_raw=True)
         except (QingflowApiError, RuntimeError) as error:
@@ -6559,22 +6602,25 @@ class AiBuilderFacade:
             )
         raw_base = base_result.get("result") if isinstance(base_result.get("result"), dict) else {}
         effective_title = str(raw_base.get("formTitle") or fallback_title or "未命名应用").strip() or "未命名应用"
+        desired_title = str(app_name or effective_title).strip() or effective_title
         existing_icon = str(raw_base.get("appIcon") or "").strip() or None
         desired_icon = encode_workspace_icon_with_defaults(
             icon=icon,
             color=color,
-            title=effective_title,
+            title=desired_title,
             fallback_icon_name="template",
             existing_icon=existing_icon,
         )
-        if desired_icon == existing_icon:
+        if desired_icon == existing_icon and desired_title == effective_title:
             return {
                 "status": "success",
                 "updated": False,
-                "app_icon": desired_icon,
+                "app_icon": desired_icon or existing_icon,
+                "app_name_before": effective_title,
+                "app_name_after": desired_title,
                 "request_id": None,
             }
-        payload = self._build_app_base_update_payload(raw_base=raw_base, form_title=effective_title, app_icon=desired_icon)
+        payload = self._build_app_base_update_payload(raw_base=raw_base, form_title=desired_title, app_icon=desired_icon)
         if payload is None:
             return _failed(
                 "APP_VISUAL_UPDATE_UNSUPPORTED",
@@ -6598,6 +6644,8 @@ class AiBuilderFacade:
             "status": "success",
             "updated": True,
             "app_icon": desired_icon,
+            "app_name_before": effective_title,
+            "app_name_after": desired_title,
             "request_id": update_result.get("request_id") if isinstance(update_result, dict) else None,
         }
 

package/src/qingflow_mcp/cli/commands/builder.py

@@ -458,13 +458,13 @@ def _handle_schema_apply(args: argparse.Namespace, context: CliContext) -> dict:
     has_app_title = bool((args.app_title or "").strip())
     has_package_tag_id = args.package_tag_id is not None
     if has_app_key:
-        if args.create_if_missing or has_app_name or has_package_tag_id or has_app_title:
+        if args.create_if_missing or has_package_tag_id:
             raise_config_error(
-                "schema apply edit mode only accepts --app-key as the resource selector.",
-                fix_hint="For existing apps, pass `--app-key` only. For create mode, use `--package-tag-id --app-name --create-if-missing`.",
+                "schema apply edit mode accepts --app-key and optional --app-name only.",
+                fix_hint="For existing apps, use `--app-key` and optionally `--app-name`. For create mode, use `--package-tag-id --app-name --create-if-missing`.",
             )
     else:
-        if not args.create_if_missing or not has_package_tag_id or not has_app_name:
+        if not args.create_if_missing or not has_package_tag_id or not (has_app_name or has_app_title):
             raise_config_error(
                 "schema apply create mode requires --package-tag-id, --app-name, and --create-if-missing.",
                 fix_hint="Use `--app-key` for existing apps, or pass `--package-tag-id --app-name --create-if-missing` to create a new app.",

package/src/qingflow_mcp/cli/commands/record.py

@@ -73,8 +73,10 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
 
     update = record_subparsers.add_parser("update", help="更新记录")
     update.add_argument("--app-key", required=True)
-    update.add_argument("--record-id", required=True, type=int)
-    update.add_argument("--fields-file", required=True)
+    update.add_argument("--record-id", type=int)
+    update.add_argument("--fields-file")
+    update.add_argument("--items-file")
+    update.add_argument("--dry-run", action=argparse.BooleanOptionalAction, default=False)
     update.add_argument("--verify-write", action=argparse.BooleanOptionalAction, default=True)
     update.set_defaults(handler=_handle_update, format_hint="")
 
@@ -242,6 +244,31 @@ def _handle_insert(args: argparse.Namespace, context: CliContext) -> dict:
 
 
 def _handle_update(args: argparse.Namespace, context: CliContext) -> dict:
+    if args.items_file:
+        if args.record_id is not None or args.fields_file:
+            raise_config_error(
+                "record update batch mode does not accept --record-id or --fields-file.",
+                fix_hint="Use `record update --app-key APP_KEY --items-file ITEMS.json [--dry-run]` for batch updates.",
+            )
+        return context.record.record_update_public(
+            profile=args.profile,
+            app_key=args.app_key,
+            record_id=None,
+            fields=None,
+            items=require_list_arg(args.items_file, option_name="--items-file"),
+            dry_run=bool(args.dry_run),
+            verify_write=bool(args.verify_write),
+        )
+    if args.dry_run:
+        raise_config_error(
+            "record update --dry-run currently requires --items-file.",
+            fix_hint="Use `record update --app-key APP_KEY --items-file ITEMS.json --dry-run` for batch preflight.",
+        )
+    if args.record_id is None or not args.fields_file:
+        raise_config_error(
+            "record update single mode requires --record-id and --fields-file.",
+            fix_hint="Use `record update --app-key APP_KEY --record-id RECORD_ID --fields-file FIELDS.json`.",
+        )
     return context.record.record_update_public(
         profile=args.profile,
         app_key=args.app_key,

package/src/qingflow_mcp/cli/commands/task.py

@@ -37,13 +37,6 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     action.add_argument("--fields-file")
     action.set_defaults(handler=_handle_action, format_hint="")
 
-    save_only = task_subparsers.add_parser("save-only", help="仅保存当前待办字段，不提交流程")
-    save_only.add_argument("--app-key", required=True)
-    save_only.add_argument("--record-id", required=True, type=int)
-    save_only.add_argument("--workflow-node-id", required=True, type=int)
-    save_only.add_argument("--fields-file", required=True)
-    save_only.set_defaults(handler=_handle_save_only, format_hint="")
-
     log = task_subparsers.add_parser("log", help="读取流程日志")
     log.add_argument("--app-key", required=True)
     log.add_argument("--record-id", required=True, type=int)
@@ -87,16 +80,6 @@ def _handle_action(args: argparse.Namespace, context: CliContext) -> dict:
     )
 
 
-def _handle_save_only(args: argparse.Namespace, context: CliContext) -> dict:
-    return context.task.task_save_only(
-        profile=args.profile,
-        app_key=args.app_key,
-        record_id=args.record_id,
-        workflow_node_id=args.workflow_node_id,
-        fields=load_object_arg(args.fields_file, option_name="--fields-file") or {},
-    )
-
-
 def _handle_log(args: argparse.Namespace, context: CliContext) -> dict:
     return context.task.task_workflow_log_get(
         profile=args.profile,

package/src/qingflow_mcp/public_surface.py

@@ -91,7 +91,6 @@ USER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(USER_DOMAIN, "record_code_block_run", ("record_code_block_run",), ("record", "code-block-run")),
     PublicToolSpec(USER_DOMAIN, "task_list", ("task_list",), ("task", "list")),
     PublicToolSpec(USER_DOMAIN, "task_get", ("task_get",), ("task", "get")),
-    PublicToolSpec(USER_DOMAIN, "task_save_only", ("task_save_only",), ("task", "save-only")),
     PublicToolSpec(USER_DOMAIN, "task_action_execute", ("task_action_execute",), ("task", "action")),
     PublicToolSpec(USER_DOMAIN, "task_associated_report_detail_get", ("task_associated_report_detail_get",), cli_public=False),
     PublicToolSpec(USER_DOMAIN, "task_workflow_log_get", ("task_workflow_log_get",), ("task", "log")),

package/src/qingflow_mcp/response_trim.py

@@ -413,7 +413,6 @@ _register_policy(
     (USER_DOMAIN,),
     (
         "task_get",
-        "task_save_only",
         "task_action_execute",
         "task_associated_report_detail_get",
         "task_workflow_log_get",

package/src/qingflow_mcp/server_app_builder.py

@@ -399,12 +399,12 @@ def build_builder_server() -> FastMCP:
         has_app_title = bool((app_title or "").strip())
         has_package_tag_id = package_tag_id is not None
         if has_app_key:
-            if create_if_missing or has_app_name or has_package_tag_id or has_app_title:
+            if create_if_missing or has_package_tag_id:
                 return _config_failure(
-                    "app_schema_apply edit mode only accepts app_key as the resource selector.",
-                    fix_hint="For existing apps, pass `app_key` only. For create mode, use `package_tag_id + app_name + create_if_missing=true`.",
+                    "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_tag_id + app_name + create_if_missing=true`.",
                 )
-        elif not (create_if_missing and has_package_tag_id and has_app_name):
+        elif not (create_if_missing and has_package_tag_id and (has_app_name or has_app_title)):
             return _config_failure(
                 "app_schema_apply create mode requires package_tag_id, app_name, and create_if_missing=true.",
                 fix_hint="Use `app_key` for existing apps, or pass `package_tag_id + app_name + create_if_missing=true` to create a new app.",

package/src/qingflow_mcp/server_app_user.py

@@ -144,13 +144,13 @@ Use `record_code_block_run` when the user wants to execute a form code-block fie
 
 ## Task Workflow Path
 
-`task_list -> task_get -> task_save_only / task_action_execute`
+`task_list -> task_get -> task_action_execute`
 
 - Use `task_associated_report_detail_get` for associated view or report details.
 - Use `task_workflow_log_get` for full workflow log history.
 - 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_save_only` when the user wants to save editable field changes on the current node without advancing the workflow.
+- 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.
 - `save_only` is exposed only when the backend current-node `editableQueIds` signal returns a non-empty result; MCP no longer infers `save_only` from local schema reconstruction.
 
 ## Time Handling

package/src/qingflow_mcp/tools/ai_builder_tools.py

@@ -299,13 +299,13 @@ class AiBuilderTools(ToolBase):
             has_app_title = bool((app_title or "").strip())
             has_package_tag_id = package_tag_id is not None
             if has_app_key:
-                if create_if_missing or has_app_name or has_package_tag_id or has_app_title:
+                if create_if_missing or has_package_tag_id:
                     return _config_failure(
                         tool_name="app_schema_apply",
-                        message="app_schema_apply edit mode only accepts app_key as the resource selector.",
-                        fix_hint="For existing apps, pass `app_key` only. For create mode, use `package_tag_id + app_name + create_if_missing=true`.",
+                        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_tag_id + app_name + create_if_missing=true`.",
                     )
-            elif not (create_if_missing and has_package_tag_id and has_app_name):
+            elif not (create_if_missing and has_package_tag_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_tag_id, app_name, and create_if_missing=true.",
@@ -2365,7 +2365,7 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
         },
         "execution_notes": [
             "use exactly one resource mode",
-            "edit mode: app_key",
+            "edit mode: app_key, optional app_name to rename the existing app",
             "create mode: package_tag_id + app_name + create_if_missing=true",
             "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",
@@ -2392,6 +2392,15 @@ _BUILDER_TOOL_CONTRACTS: dict[str, JSONObject] = {
             "update_fields": [],
             "remove_fields": [],
         },
+        "rename_example": {
+            "profile": "default",
+            "app_key": "APP_PROJECT",
+            "app_name": "项目主数据",
+            "publish": True,
+            "add_fields": [],
+            "update_fields": [],
+            "remove_fields": [],
+        },
         "relation_example": {
             "profile": "default",
             "app_key": "APP_ITERATION",

package/src/qingflow_mcp/tools/approval_tools.py

@@ -117,22 +117,6 @@ class ApprovalTools(ToolBase):
         ) -> dict[str, Any]:
             return self.task_transfer(profile=profile, app_key=app_key, record_id=record_id, payload=payload or {}, fields=fields or {})
 
-        @mcp.tool(description=self._high_risk_tool_description(operation="save", target="workflow task fields without advancing the workflow"))
-        def task_save_only(
-            profile: str = DEFAULT_PROFILE,
-            app_key: str = "",
-            record_id: int = 0,
-            workflow_node_id: int = 0,
-            fields: dict[str, Any] | None = None,
-        ) -> dict[str, Any]:
-            return self.task_save_only(
-                profile=profile,
-                app_key=app_key,
-                record_id=record_id,
-                workflow_node_id=workflow_node_id,
-                fields=fields or {},
-            )
-
         @mcp.tool()
         def task_transfer_candidates(
             profile: str = DEFAULT_PROFILE,

package/src/qingflow_mcp/tools/record_tools.py

@@ -460,6 +460,8 @@ class RecordTools(ToolBase):
             app_key: str = "",
             record_id: int | None = None,
             fields: JSONObject | None = None,
+            items: list[JSONObject] | None = None,
+            dry_run: bool = False,
             verify_write: bool = True,
             output_profile: str = "normal",
         ) -> JSONObject:
@@ -467,7 +469,9 @@ class RecordTools(ToolBase):
                 profile=DEFAULT_PROFILE,
                 app_key=app_key,
                 record_id=record_id,
-                fields=fields or {},
+                fields=fields,
+                items=items,
+                dry_run=dry_run,
                 verify_write=verify_write,
                 output_profile=output_profile,
             )
@@ -1640,6 +1644,8 @@ class RecordTools(ToolBase):
                     ),
                 }
             )
+        rows = list_data.get("rows", [])
+        normalized_public_rows = _normalize_public_record_rows(rows if isinstance(rows, list) else [])
         response: JSONObject = {
             "profile": profile,
             "ws_id": raw.get("ws_id"),
@@ -1650,7 +1656,7 @@ class RecordTools(ToolBase):
             "output_profile": normalized_output_profile,
             "data": {
                 "app_key": app_key,
-                "items": list_data.get("rows", []),
+                "items": normalized_public_rows,
                 "pagination": {
                     "page": page,
                     "limit": limit,
@@ -1818,7 +1824,7 @@ class RecordTools(ToolBase):
                 "output_profile": normalized_output_profile,
                 "data": {
                     "app_key": app_key,
-                    "record_id": record_id,
+                    "record_id": _public_record_id_text(record_id),
                     "record": row,
                     "selection": {
                         "columns": [_column_selector_payload(field_id) for field_id in normalized_columns] if normalized_columns else [],
@@ -1918,21 +1924,60 @@ class RecordTools(ToolBase):
         app_key: str,
         record_id: int | None,
         fields: JSONObject | None = None,
+        items: list[JSONObject] | None = None,
+        dry_run: bool = False,
         verify_write: bool = True,
         output_profile: str = "normal",
     ) -> JSONObject:
         normalized_output_profile = self._normalize_public_output_profile(output_profile)
         if not app_key:
             raise_tool_error(QingflowApiError.config_error("app_key is required"))
+        if items is not None:
+            if dry_run not in {True, False}:
+                raise_tool_error(QingflowApiError.config_error("dry_run must be boolean"))
+            normalized_items = self._normalize_public_record_update_batch_items(
+                record_id=record_id,
+                fields=fields,
+                items=items,
+            )
+            return self._record_update_public_batch(
+                profile=profile,
+                app_key=app_key,
+                items=normalized_items,
+                dry_run=dry_run,
+                verify_write=verify_write,
+                output_profile=normalized_output_profile,
+            )
+        if dry_run:
+            raise_tool_error(QingflowApiError.config_error("dry_run currently requires items"))
         if record_id is None or record_id <= 0:
             raise_tool_error(QingflowApiError.config_error("record_id is required"))
         if fields is not None and not isinstance(fields, dict):
             raise_tool_error(QingflowApiError.config_error("fields must be an object map keyed by field title"))
-        raw_preflight = self._preflight_record_update_with_auto_view(
+        return self._record_update_public_single(
             profile=profile,
             app_key=app_key,
             record_id=record_id,
             fields=cast(JSONObject, fields or {}),
+            verify_write=verify_write,
+            output_profile=normalized_output_profile,
+        )
+
+    def _record_update_public_single(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int,
+        fields: JSONObject,
+        verify_write: bool,
+        output_profile: str,
+    ) -> JSONObject:
+        raw_preflight = self._preflight_record_update_with_auto_view(
+            profile=profile,
+            app_key=app_key,
+            record_id=record_id,
+            fields=fields,
             force_refresh_form=False,
         )
         preflight_used_force_refresh = self._record_preflight_used_force_refresh(raw_preflight)
@@ -1950,7 +1995,7 @@ class RecordTools(ToolBase):
                 raw_preflight,
                 operation="update",
                 normalized_payload=normalized_payload,
-                output_profile=normalized_output_profile,
+                output_profile=output_profile,
                 human_review=True,
                 target_resource={"type": "record", "app_key": app_key, "record_id": record_id, "record_ids": []},
             )
@@ -1978,11 +2023,257 @@ class RecordTools(ToolBase):
             raw_apply,
             operation="update",
             normalized_payload=normalized_payload,
-            output_profile=normalized_output_profile,
+            output_profile=output_profile,
             human_review=True,
             preflight=raw_preflight,
         )
 
+    def _record_update_public_batch(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        items: list[JSONObject],
+        dry_run: bool,
+        verify_write: bool,
+        output_profile: str,
+    ) -> JSONObject:
+        preflight_responses = [
+            self._record_update_public_preflight_response(
+                profile=profile,
+                app_key=app_key,
+                record_id=cast(int, item["record_id"]),
+                fields=cast(JSONObject, item["fields"]),
+                output_profile=output_profile,
+            )
+            for item in items
+        ]
+        has_preflight_blockers = any(
+            str(response.get("status") or "").lower() in {"blocked", "needs_confirmation"}
+            for response in preflight_responses
+        )
+        if dry_run or has_preflight_blockers:
+            return self._record_update_batch_response(
+                profile=profile,
+                app_key=app_key,
+                responses=preflight_responses,
+                output_profile=output_profile,
+                dry_run=dry_run,
+            )
+
+        apply_responses: list[JSONObject] = []
+        for item in items:
+            record_id = cast(int, item["record_id"])
+            fields = cast(JSONObject, item["fields"])
+            try:
+                apply_responses.append(
+                    self._record_update_public_single(
+                        profile=profile,
+                        app_key=app_key,
+                        record_id=record_id,
+                        fields=fields,
+                        verify_write=verify_write,
+                        output_profile=output_profile,
+                    )
+                )
+            except (QingflowApiError, RuntimeError) as exc:
+                apply_responses.append(
+                    self._record_write_exception_response(
+                        exc,
+                        operation="update",
+                        profile=profile,
+                        app_key=app_key,
+                        record_id=record_id,
+                        output_profile=output_profile,
+                        human_review=True,
+                    )
+                )
+
+        return self._record_update_batch_response(
+            profile=profile,
+            app_key=app_key,
+            responses=apply_responses,
+            output_profile=output_profile,
+            dry_run=False,
+        )
+
+    def _record_update_public_preflight_response(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int,
+        fields: JSONObject,
+        output_profile: str,
+    ) -> JSONObject:
+        raw_preflight = self._preflight_record_update_with_auto_view(
+            profile=profile,
+            app_key=app_key,
+            record_id=record_id,
+            fields=fields,
+            force_refresh_form=False,
+        )
+        preflight_data = cast(JSONObject, raw_preflight.get("data", {}))
+        normalized_payload = self._record_write_normalized_payload(
+            operation="update",
+            record_id=record_id,
+            record_ids=[],
+            normalized_answers=cast(list[JSONObject], preflight_data.get("normalized_answers", [])),
+            submit_type=1,
+            selection=cast(JSONObject | None, preflight_data.get("selection") if isinstance(preflight_data.get("selection"), dict) else None),
+        )
+        confirmation_requests = cast(list[JSONObject], preflight_data.get("confirmation_requests", []))
+        if preflight_data.get("blockers") or confirmation_requests:
+            return self._record_write_blocked_response(
+                raw_preflight,
+                operation="update",
+                normalized_payload=normalized_payload,
+                output_profile=output_profile,
+                human_review=True,
+                target_resource={"type": "record", "app_key": app_key, "record_id": record_id, "record_ids": []},
+            )
+        return self._record_write_ready_response(
+            raw_preflight,
+            operation="update",
+            normalized_payload=normalized_payload,
+            output_profile=output_profile,
+            human_review=True,
+            target_resource={"type": "record", "app_key": app_key, "record_id": record_id, "record_ids": []},
+        )
+
+    def _normalize_public_record_update_batch_items(
+        self,
+        *,
+        record_id: int | None,
+        fields: JSONObject | None,
+        items: list[JSONObject] | None,
+    ) -> list[JSONObject]:
+        if record_id is not None or fields is not None:
+            raise_tool_error(
+                QingflowApiError.config_error("record_update batch mode does not accept record_id or fields")
+            )
+        if not isinstance(items, list) or not items:
+            raise_tool_error(QingflowApiError.config_error("items must be a non-empty list"))
+        normalized_items: list[JSONObject] = []
+        seen_record_ids: set[int] = set()
+        for index, item in enumerate(items):
+            if not isinstance(item, dict):
+                raise_tool_error(QingflowApiError.config_error(f"items[{index}] must be an object"))
+            normalized_record_id = _coerce_count(item.get("record_id"))
+            if normalized_record_id is None or normalized_record_id <= 0:
+                raise_tool_error(QingflowApiError.config_error(f"items[{index}].record_id must be a positive integer"))
+            if normalized_record_id in seen_record_ids:
+                raise_tool_error(
+                    QingflowApiError.config_error(f"duplicate record_id in items: {normalized_record_id}")
+                )
+            item_fields = item.get("fields")
+            if not isinstance(item_fields, dict):
+                raise_tool_error(QingflowApiError.config_error(f"items[{index}].fields must be an object map keyed by field title"))
+            seen_record_ids.add(normalized_record_id)
+            normalized_items.append({"record_id": normalized_record_id, "fields": cast(JSONObject, item_fields)})
+        return normalized_items
+
+    def _record_update_batch_response(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        responses: list[JSONObject],
+        output_profile: str,
+        dry_run: bool,
+    ) -> JSONObject:
+        summary = self._record_update_batch_summary(responses)
+        batch_items = [self._record_update_batch_item_from_response(response, output_profile=output_profile) for response in responses]
+        status, ok, message = self._record_update_batch_envelope_status(summary=summary, dry_run=dry_run)
+        first_response = responses[0] if responses else {}
+        return {
+            "profile": first_response.get("profile", profile),
+            "ws_id": first_response.get("ws_id"),
+            "ok": ok,
+            "status": status,
+            "request_route": first_response.get("request_route"),
+            "warnings": [],
+            "output_profile": output_profile,
+            "data": {
+                "app_key": app_key,
+                "mode": "batch",
+                "dry_run": dry_run,
+                "summary": summary,
+                "items": batch_items,
+            },
+            "message": message,
+        }
+
+    def _record_update_batch_summary(self, responses: list[JSONObject]) -> JSONObject:
+        summary: JSONObject = {
+            "total": len(responses),
+            "ready_count": 0,
+            "blocked_count": 0,
+            "confirmation_count": 0,
+            "applied_count": 0,
+            "verified_count": 0,
+            "field_level_verified_count": 0,
+            "failed_count": 0,
+        }
+        for response in responses:
+            status = str(response.get("status") or "").lower()
+            data = cast(JSONObject, response.get("data", {}))
+            action = cast(JSONObject, data.get("action", {}))
+            verification = cast(JSONObject, data.get("verification", {})) if isinstance(data.get("verification"), dict) else {}
+            executed = bool(action.get("executed"))
+            if status == "ready":
+                summary["ready_count"] = int(summary["ready_count"]) + 1
+                continue
+            if status == "blocked":
+                summary["blocked_count"] = int(summary["blocked_count"]) + 1
+                continue
+            if status == "needs_confirmation":
+                summary["confirmation_count"] = int(summary["confirmation_count"]) + 1
+                continue
+            if executed:
+                summary["applied_count"] = int(summary["applied_count"]) + 1
+            if bool(verification.get("verified")):
+                summary["verified_count"] = int(summary["verified_count"]) + 1
+            if bool(verification.get("field_level_verified")):
+                summary["field_level_verified_count"] = int(summary["field_level_verified_count"]) + 1
+            if status not in {"success"}:
+                summary["failed_count"] = int(summary["failed_count"]) + 1
+        return summary
+
+    def _record_update_batch_envelope_status(self, *, summary: JSONObject, dry_run: bool) -> tuple[str, bool, str]:
+        if int(summary["blocked_count"]) > 0:
+            return "blocked", False, "batch update preflight blocked"
+        if int(summary["confirmation_count"]) > 0:
+            return "needs_confirmation", False, "batch update requires confirmation before write"
+        if dry_run:
+            return "ready", True, "batch update dry run ready"
+        if int(summary["failed_count"]) > 0:
+            return "partial_success", False, "batch update completed with partial failures"
+        return "success", True, "batch update completed"
+
+    def _record_update_batch_item_from_response(self, response: JSONObject, *, output_profile: str) -> JSONObject:
+        data = cast(JSONObject, response.get("data", {}))
+        item: JSONObject = {
+            "resource": data.get("resource"),
+            "status": response.get("status"),
+            "verification": data.get("verification"),
+            "field_errors": cast(list[JSONObject], data.get("field_errors", [])),
+            "confirmation_requests": cast(list[JSONObject], data.get("confirmation_requests", [])),
+            "resolved_fields": cast(list[JSONObject], data.get("resolved_fields", [])),
+        }
+        blockers = data.get("blockers")
+        if isinstance(blockers, list) and blockers:
+            item["blockers"] = blockers
+        warnings = response.get("warnings")
+        if isinstance(warnings, list) and warnings:
+            item["warnings"] = warnings
+        error = data.get("error")
+        if isinstance(error, dict):
+            item["error"] = error
+        if output_profile == "verbose" and isinstance(data.get("debug"), dict):
+            item["debug"] = data.get("debug")
+        return item
+
     def _preflight_record_update_with_auto_view(
         self,
         *,
@@ -7944,6 +8235,48 @@ class RecordTools(ToolBase):
             }
         return response
 
+    def _record_write_ready_response(
+        self,
+        raw_preflight: JSONObject,
+        *,
+        operation: str,
+        normalized_payload: JSONObject,
+        output_profile: str,
+        human_review: bool,
+        target_resource: JSONObject,
+    ) -> JSONObject:
+        plan_data = cast(JSONObject, raw_preflight.get("data", {}))
+        validation = cast(JSONObject, plan_data.get("validation", {}))
+        resolved_fields = cast(list[JSONObject], plan_data.get("lookup_resolved_fields", []))
+        warnings_payload = validation.get("warnings", [])
+        warnings = [{"code": "PREFLIGHT_WARNING", "message": str(item)} for item in warnings_payload] if isinstance(warnings_payload, list) else []
+        response: JSONObject = {
+            "profile": raw_preflight.get("profile"),
+            "ws_id": raw_preflight.get("ws_id"),
+            "ok": True,
+            "status": "ready",
+            "request_route": raw_preflight.get("request_route"),
+            "warnings": warnings,
+            "output_profile": output_profile,
+            "data": {
+                "action": {"operation": operation, "executed": False},
+                "resource": target_resource,
+                "verification": None,
+                "normalized_payload": normalized_payload,
+                "blockers": [],
+                "field_errors": [],
+                "confirmation_requests": [],
+                "resolved_fields": resolved_fields,
+                "recommended_next_actions": cast(list[JSONValue], plan_data.get("recommended_next_actions", [])),
+                "human_review": self._record_write_human_review_payload(operation, enabled=human_review),
+            },
+        }
+        if output_profile == "verbose":
+            response["data"]["debug"] = {
+                "preflight": plan_data,
+            }
+        return response
+
     def _record_write_apply_response(
         self,
         raw_apply: JSONObject,
@@ -7994,6 +8327,67 @@ class RecordTools(ToolBase):
             response["data"]["debug"] = debug
         return response
 
+    def _record_write_exception_response(
+        self,
+        exc: QingflowApiError | RuntimeError,
+        *,
+        operation: str,
+        profile: str,
+        app_key: str,
+        record_id: int,
+        output_profile: str,
+        human_review: bool,
+    ) -> JSONObject:
+        error_payload: JSONObject = {
+            "error_code": "RECORD_WRITE_EXECUTION_FAILED",
+            "message": str(exc),
+        }
+        request_route: JSONObject | None = None
+        if isinstance(exc, QingflowApiError):
+            error_payload["message"] = exc.message
+            if exc.backend_code is not None:
+                error_payload["backend_code"] = exc.backend_code
+            if exc.request_id is not None:
+                error_payload["request_id"] = exc.request_id
+        else:
+            try:
+                parsed = json.loads(str(exc))
+            except json.JSONDecodeError:
+                parsed = None
+            if isinstance(parsed, dict):
+                error_payload["error_code"] = parsed.get("error_code") or cast(JSONObject, parsed.get("details", {})).get("error_code") or error_payload["error_code"]
+                error_payload["message"] = parsed.get("message") or error_payload["message"]
+                if parsed.get("backend_code") is not None:
+                    error_payload["backend_code"] = parsed.get("backend_code")
+                if parsed.get("request_id") is not None:
+                    error_payload["request_id"] = parsed.get("request_id")
+                if isinstance(parsed.get("request_route"), dict):
+                    request_route = cast(JSONObject, parsed.get("request_route"))
+        response: JSONObject = {
+            "profile": profile,
+            "ws_id": None,
+            "ok": False,
+            "status": "failed",
+            "request_route": request_route,
+            "warnings": [],
+            "output_profile": output_profile,
+            "data": {
+                "action": {"operation": operation, "executed": True},
+                "resource": {"type": "record", "app_key": app_key, "record_id": record_id, "record_ids": []},
+                "verification": None,
+                "normalized_payload": None,
+                "blockers": [],
+                "field_errors": [],
+                "confirmation_requests": [],
+                "resolved_fields": [],
+                "human_review": self._record_write_human_review_payload(operation, enabled=human_review),
+                "error": error_payload,
+            },
+        }
+        if output_profile == "verbose":
+            response["data"]["debug"] = {"exception": error_payload}
+        return response
+
     def _record_write_public_field_errors(self, plan_data: JSONObject) -> list[JSONObject]:
         existing = plan_data.get("field_errors")
         if isinstance(existing, list):
@@ -10221,12 +10615,36 @@ def _view_selection_supported_by_search_ids(view_selection: ViewSelection, searc
 
 
 def _build_flat_row(answer_list: list[JSONValue], fields: list[FormField], *, apply_id: int | None) -> JSONObject:
-    row: JSONObject = {"apply_id": apply_id}
+    public_record_id = _public_record_id_text(apply_id)
+    row: JSONObject = {"apply_id": public_record_id, "record_id": public_record_id}
     for field in fields:
         row[field.que_title] = _extract_field_value(answer_list, field)
     return row
 
 
+def _public_record_id_text(record_id: int | None) -> str | None:
+    if record_id is None or record_id <= 0:
+        return None
+    return str(record_id)
+
+
+def _normalize_public_record_rows(rows: list[JSONValue]) -> list[JSONObject]:
+    normalized_rows: list[JSONObject] = []
+    for item in rows:
+        if not isinstance(item, dict):
+            continue
+        row = dict(item)
+        normalized_record_id = _coerce_count(row.get("apply_id"))
+        if normalized_record_id is None:
+            normalized_record_id = _coerce_count(row.get("record_id"))
+        if normalized_record_id is not None and normalized_record_id > 0:
+            public_record_id = _public_record_id_text(normalized_record_id)
+            row["apply_id"] = public_record_id
+            row["record_id"] = public_record_id
+        normalized_rows.append(row)
+    return normalized_rows
+
+
 def _merge_answer_lists_by_field_id(existing: list[JSONValue], extra: list[JSONValue]) -> list[JSONValue]:
     merged: dict[str, JSONValue] = {}
     order: list[str] = []

package/src/qingflow_mcp/tools/task_context_tools.py

@@ -104,22 +104,6 @@ class TaskContextTools(ToolBase):
                 fields=fields or {},
             )
 
-        @mcp.tool()
-        def task_save_only(
-            profile: str = DEFAULT_PROFILE,
-            app_key: str = "",
-            record_id: int = 0,
-            workflow_node_id: int = 0,
-            fields: dict[str, Any] | None = None,
-        ) -> dict[str, Any]:
-            return self.task_save_only(
-                profile=profile,
-                app_key=app_key,
-                record_id=record_id,
-                workflow_node_id=workflow_node_id,
-                fields=fields or {},
-            )
-
         @mcp.tool()
         def task_associated_report_detail_get(
             profile: str = DEFAULT_PROFILE,