@josephyan/qingflow-cli 0.2.0-beta.61 → 0.2.0-beta.62

package/README.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-cli",
-  "version": "0.2.0-beta.61",
+  "version": "0.2.0-beta.62",
   "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.0b61"
+version = "0.2.0b62"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

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

@@ -26,7 +26,7 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     get.add_argument("--workflow-node-id", required=True, type=int)
     get.add_argument("--include-candidates", action=argparse.BooleanOptionalAction, default=True)
     get.add_argument("--include-associated-reports", action=argparse.BooleanOptionalAction, default=True)
-    get.set_defaults(handler=_handle_get, format_hint="")
+    get.set_defaults(handler=_handle_get, format_hint="task_get")
 
     action = task_subparsers.add_parser("action", help="执行待办动作")
     action.add_argument("--app-key", required=True)
@@ -34,6 +34,7 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     action.add_argument("--workflow-node-id", required=True, type=int)
     action.add_argument("--action", required=True)
     action.add_argument("--payload-file")
+    action.add_argument("--fields-file")
     action.set_defaults(handler=_handle_action, format_hint="")
 
     log = task_subparsers.add_parser("log", help="读取流程日志")
@@ -75,6 +76,7 @@ def _handle_action(args: argparse.Namespace, context: CliContext) -> dict:
         workflow_node_id=args.workflow_node_id,
         action=args.action,
         payload=load_object_arg(args.payload_file, option_name="--payload-file") or {},
+        fields=load_object_arg(args.fields_file, option_name="--fields-file") or {},
     )
 
 

package/src/qingflow_mcp/cli/formatters.py

@@ -137,6 +137,41 @@ def _format_task_list(result: dict[str, Any]) -> str:
     return "\n".join(lines) + "\n"
 
 
+def _format_task_get(result: dict[str, Any]) -> str:
+    data = result.get("data") if isinstance(result.get("data"), dict) else {}
+    task = data.get("task") if isinstance(data.get("task"), dict) else {}
+    record = data.get("record") if isinstance(data.get("record"), dict) else {}
+    capabilities = data.get("capabilities") if isinstance(data.get("capabilities"), dict) else {}
+    update_schema = data.get("update_schema") if isinstance(data.get("update_schema"), dict) else {}
+    writable_fields = update_schema.get("writable_fields") if isinstance(update_schema.get("writable_fields"), list) else []
+    lines = [
+        f"Task: {task.get('app_key') or '-'} / {task.get('record_id') or '-'} / {task.get('workflow_node_id') or '-'}",
+        f"Node: {task.get('workflow_node_name') or '-'}",
+        f"Apply Status: {record.get('apply_status')}",
+        f"Available Actions: {', '.join(str(item) for item in (capabilities.get('available_actions') or [])) or '-'}",
+        f"Editable Fields: {len(writable_fields)}",
+    ]
+    if writable_fields:
+        for item in writable_fields[:10]:
+            if isinstance(item, dict):
+                lines.append(f"- {item.get('title') or '-'} ({item.get('kind') or 'field'})")
+    blockers = update_schema.get("blockers") if isinstance(update_schema.get("blockers"), list) else []
+    if blockers:
+        lines.append("Update Schema Blockers:")
+        for item in blockers:
+            lines.append(f"- {item}")
+    schema_warnings = update_schema.get("warnings") if isinstance(update_schema.get("warnings"), list) else []
+    if schema_warnings:
+        lines.append("Update Schema Warnings:")
+        for item in schema_warnings:
+            if isinstance(item, dict):
+                lines.append(f"- {item.get('code') or 'WARNING'}: {item.get('message') or ''}".rstrip())
+            else:
+                lines.append(f"- {item}")
+    _append_warnings(lines, result.get("warnings"))
+    return "\n".join(lines) + "\n"
+
+
 def _format_import_verify(result: dict[str, Any]) -> str:
     lines = [
         f"App Key: {result.get('app_key') or '-'}",
@@ -263,6 +298,7 @@ _FORMATTERS = {
     "app_get": _format_app_get,
     "record_list": _format_record_list,
     "task_list": _format_task_list,
+    "task_get": _format_task_get,
     "import_verify": _format_import_verify,
     "import_status": _format_import_status,
     "builder_summary": _format_builder_summary,

package/src/qingflow_mcp/tools/approval_tools.py

@@ -69,12 +69,24 @@ class ApprovalTools(ToolBase):
             return self.record_comment_mark_read(profile=profile, app_key=app_key, apply_id=record_id)
 
         @mcp.tool(description=self._high_risk_tool_description(operation="approve", target="workflow task"))
-        def task_approve(profile: str = DEFAULT_PROFILE, app_key: str = "", record_id: int = 0, payload: dict[str, Any] | None = None) -> dict[str, Any]:
-            return self.task_approve(profile=profile, app_key=app_key, record_id=record_id, payload=payload or {})
+        def task_approve(
+            profile: str = DEFAULT_PROFILE,
+            app_key: str = "",
+            record_id: int = 0,
+            payload: dict[str, Any] | None = None,
+            fields: dict[str, Any] | None = None,
+        ) -> dict[str, Any]:
+            return self.task_approve(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="reject", target="workflow task"))
-        def task_reject(profile: str = DEFAULT_PROFILE, app_key: str = "", record_id: int = 0, payload: dict[str, Any] | None = None) -> dict[str, Any]:
-            return self.task_reject(profile=profile, app_key=app_key, record_id=record_id, payload=payload or {})
+        def task_reject(
+            profile: str = DEFAULT_PROFILE,
+            app_key: str = "",
+            record_id: int = 0,
+            payload: dict[str, Any] | None = None,
+            fields: dict[str, Any] | None = None,
+        ) -> dict[str, Any]:
+            return self.task_reject(profile=profile, app_key=app_key, record_id=record_id, payload=payload or {}, fields=fields or {})
 
         @mcp.tool()
         def task_rollback_candidates(
@@ -86,12 +98,40 @@ class ApprovalTools(ToolBase):
             return self.task_rollback_candidates(profile=profile, app_key=app_key, record_id=record_id, workflow_node_id=workflow_node_id)
 
         @mcp.tool()
-        def task_rollback(profile: str = DEFAULT_PROFILE, app_key: str = "", record_id: int = 0, payload: dict[str, Any] | None = None) -> dict[str, Any]:
-            return self.task_rollback(profile=profile, app_key=app_key, record_id=record_id, payload=payload or {})
+        def task_rollback(
+            profile: str = DEFAULT_PROFILE,
+            app_key: str = "",
+            record_id: int = 0,
+            payload: dict[str, Any] | None = None,
+            fields: dict[str, Any] | None = None,
+        ) -> dict[str, Any]:
+            return self.task_rollback(profile=profile, app_key=app_key, record_id=record_id, payload=payload or {}, fields=fields or {})
 
         @mcp.tool()
-        def task_transfer(profile: str = DEFAULT_PROFILE, app_key: str = "", record_id: int = 0, payload: dict[str, Any] | None = None) -> dict[str, Any]:
-            return self.task_transfer(profile=profile, app_key=app_key, record_id=record_id, payload=payload or {})
+        def task_transfer(
+            profile: str = DEFAULT_PROFILE,
+            app_key: str = "",
+            record_id: int = 0,
+            payload: dict[str, Any] | None = None,
+            fields: dict[str, Any] | None = None,
+        ) -> 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(
@@ -156,7 +196,17 @@ class ApprovalTools(ToolBase):
             selection={"app_key": app_key, "record_id": record_id, "list_type": list_type, "keyword": keyword},
         )
 
-    def task_approve(self, *, profile: str, app_key: str, record_id: int, payload: dict[str, Any]) -> dict[str, Any]:
+    def task_approve(self, *, profile: str, app_key: str, record_id: int, payload: dict[str, Any], fields: dict[str, Any] | None = None) -> dict[str, Any]:
+        if fields:
+            return self._delegate_task_action(
+                profile=profile,
+                app_key=app_key,
+                record_id=record_id,
+                action="approve",
+                payload=payload,
+                fields=fields,
+                public_action="task_approve",
+            )
         raw = self.record_approve(profile=profile, app_key=app_key, apply_id=record_id, payload=payload)
         return self._public_action_response(
             raw,
@@ -166,7 +216,17 @@ class ApprovalTools(ToolBase):
             human_review=True,
         )
 
-    def task_reject(self, *, profile: str, app_key: str, record_id: int, payload: dict[str, Any]) -> dict[str, Any]:
+    def task_reject(self, *, profile: str, app_key: str, record_id: int, payload: dict[str, Any], fields: dict[str, Any] | None = None) -> dict[str, Any]:
+        if fields:
+            return self._delegate_task_action(
+                profile=profile,
+                app_key=app_key,
+                record_id=record_id,
+                action="reject",
+                payload=payload,
+                fields=fields,
+                public_action="task_reject",
+            )
         raw = self.record_reject(profile=profile, app_key=app_key, apply_id=record_id, payload=payload)
         return self._public_action_response(
             raw,
@@ -186,7 +246,17 @@ class ApprovalTools(ToolBase):
             selection={"app_key": app_key, "record_id": record_id, "workflow_node_id": workflow_node_id},
         )
 
-    def task_rollback(self, *, profile: str, app_key: str, record_id: int, payload: dict[str, Any]) -> dict[str, Any]:
+    def task_rollback(self, *, profile: str, app_key: str, record_id: int, payload: dict[str, Any], fields: dict[str, Any] | None = None) -> dict[str, Any]:
+        if fields:
+            return self._delegate_task_action(
+                profile=profile,
+                app_key=app_key,
+                record_id=record_id,
+                action="rollback",
+                payload=payload,
+                fields=fields,
+                public_action="task_rollback",
+            )
         raw = self.record_rollback(profile=profile, app_key=app_key, apply_id=record_id, payload=payload)
         return self._public_action_response(
             raw,
@@ -196,7 +266,17 @@ class ApprovalTools(ToolBase):
             human_review=True,
         )
 
-    def task_transfer(self, *, profile: str, app_key: str, record_id: int, payload: dict[str, Any]) -> dict[str, Any]:
+    def task_transfer(self, *, profile: str, app_key: str, record_id: int, payload: dict[str, Any], fields: dict[str, Any] | None = None) -> dict[str, Any]:
+        if fields:
+            return self._delegate_task_action(
+                profile=profile,
+                app_key=app_key,
+                record_id=record_id,
+                action="transfer",
+                payload=payload,
+                fields=fields,
+                public_action="task_transfer",
+            )
         raw = self.record_transfer(profile=profile, app_key=app_key, apply_id=record_id, payload=payload)
         return self._public_action_response(
             raw,
@@ -206,6 +286,26 @@ class ApprovalTools(ToolBase):
             human_review=True,
         )
 
+    def task_save_only(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int,
+        workflow_node_id: int,
+        fields: dict[str, Any],
+    ) -> dict[str, Any]:
+        return self._delegate_task_action(
+            profile=profile,
+            app_key=app_key,
+            record_id=record_id,
+            action="save_only",
+            payload={},
+            fields=fields,
+            public_action="task_save_only",
+            workflow_node_id=workflow_node_id,
+        )
+
     def task_transfer_candidates(
         self,
         *,
@@ -749,6 +849,41 @@ class ApprovalTools(ToolBase):
         if payload.get("handSignImageUrl"):
             raise_tool_error(QingflowApiError.not_supported("NOT_SUPPORTED_IN_V1: handSignImageUrl is not supported"))
 
+    def _delegate_task_action(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int,
+        action: str,
+        payload: dict[str, Any],
+        fields: dict[str, Any],
+        public_action: str,
+        workflow_node_id: int | None = None,
+    ) -> dict[str, Any]:
+        from .task_context_tools import TaskContextTools
+
+        node_id = workflow_node_id
+        if node_id is None:
+            node_payload = dict(payload or {})
+            node_id = self._extract_node_id(node_payload)
+        delegated = TaskContextTools(self.sessions, self.backend).task_action_execute(
+            profile=profile,
+            app_key=app_key,
+            record_id=record_id,
+            workflow_node_id=node_id,
+            action=action,
+            payload=payload or {},
+            fields=fields or {},
+        )
+        response = dict(delegated)
+        data = response.get("data")
+        if isinstance(data, dict):
+            payload_data = dict(data)
+            payload_data["action"] = public_action
+            response["data"] = payload_data
+        return response
+
     def _public_page_response(
         self,
         raw: dict[str, Any],

package/src/qingflow_mcp/tools/task_context_tools.py

@@ -13,6 +13,24 @@ from ..json_types import JSONObject
 from .approval_tools import ApprovalTools, _approval_page_amount, _approval_page_items, _approval_page_total
 from .base import ToolBase
 from .qingbi_report_tools import _qingbi_base_url
+from .record_tools import (
+    LAYOUT_ONLY_QUE_TYPES,
+    SUBTABLE_QUE_TYPES,
+    RecordTools,
+    _build_applicant_hidden_linked_top_level_field_index,
+    _build_applicant_top_level_field_index,
+    _build_static_schema_linkage_payloads,
+    _canonical_value_is_empty,
+    _canonicalize_answer_value_for_compare,
+    _clone_form_field,
+    _coerce_count,
+    _collect_linked_required_field_ids,
+    _collect_option_linked_field_ids,
+    _collect_question_relations,
+    _field_ref_payload,
+    _merge_field_indexes,
+    _subtable_descendant_ids,
+)
 from .task_tools import TaskTools, _task_page_amount, _task_page_items, _task_page_total
 
 
@@ -21,6 +39,7 @@ class TaskContextTools(ToolBase):
         super().__init__(sessions, backend)
         self._task_tools = TaskTools(sessions, backend)
         self._approval_tools = ApprovalTools(sessions, backend)
+        self._record_tools = RecordTools(sessions, backend)
 
     def register(self, mcp: FastMCP) -> None:
         @mcp.tool()
@@ -71,6 +90,7 @@ class TaskContextTools(ToolBase):
             workflow_node_id: int = 0,
             action: str = "",
             payload: dict[str, Any] | None = None,
+            fields: dict[str, Any] | None = None,
         ) -> dict[str, Any]:
             return self.task_action_execute(
                 profile=profile,
@@ -79,6 +99,7 @@ class TaskContextTools(ToolBase):
                 workflow_node_id=workflow_node_id,
                 action=action,
                 payload=payload or {},
+                fields=fields or {},
             )
 
         @mcp.tool()
@@ -186,7 +207,8 @@ class TaskContextTools(ToolBase):
 
         def runner(session_profile, context):
             data = self._build_task_context(
-                context,
+                profile=profile,
+                context=context,
                 app_key=app_key,
                 record_id=record_id,
                 workflow_node_id=workflow_node_id,
@@ -214,21 +236,30 @@ class TaskContextTools(ToolBase):
         workflow_node_id: int,
         action: str,
         payload: dict[str, Any],
+        fields: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         self._require_app_record_and_node(app_key, record_id, workflow_node_id)
         normalized_action = (action or "").strip().lower()
-        if normalized_action not in {"approve", "reject", "rollback", "transfer", "urge"}:
+        if normalized_action not in {"approve", "reject", "rollback", "transfer", "urge", "save_only"}:
             raise_tool_error(
                 QingflowApiError.not_supported(
-                    "TASK_ACTION_UNSUPPORTED: action must be one of approve, reject, rollback, transfer, or urge"
+                    "TASK_ACTION_UNSUPPORTED: action must be one of approve, reject, rollback, transfer, urge, or save_only"
                 )
             )
         body = dict(payload or {})
+        field_updates = dict(fields or {})
+        if field_updates and body.get("answers") is not None:
+            raise_tool_error(
+                QingflowApiError.config_error(
+                    "task actions must not provide payload.answers and fields at the same time; pass field changes through fields only"
+                )
+            )
 
         def runner(session_profile, context):
             try:
                 task_context = self._build_task_context(
-                    context,
+                    profile=profile,
+                    context=context,
                     app_key=app_key,
                     record_id=record_id,
                     workflow_node_id=workflow_node_id,
@@ -249,6 +280,10 @@ class TaskContextTools(ToolBase):
                         before_apply_status=None,
                     )
                 raise
+            if normalized_action == "save_only" and not field_updates:
+                raise_tool_error(
+                    QingflowApiError.config_error("fields is required and must be non-empty for action 'save_only'")
+                )
             capabilities = task_context.get("capabilities") or {}
             available_actions = capabilities.get("available_actions") or []
             if normalized_action not in available_actions:
@@ -264,14 +299,33 @@ class TaskContextTools(ToolBase):
                         f"payload.audit_feedback is required for action '{normalized_action}' on the current node"
                     )
                 )
+            if normalized_action == "urge" and field_updates:
+                raise_tool_error(
+                    QingflowApiError.not_supported(
+                        "TASK_ACTION_FIELDS_NOT_SUPPORTED: action 'urge' does not support fields because the downstream route does not accept task answers"
+                    )
+                )
+            prepared_fields = None
+            if field_updates:
+                prepared_fields = self._prepare_task_field_update(
+                    profile=profile,
+                    context=context,
+                    app_key=app_key,
+                    record_id=record_id,
+                    workflow_node_id=workflow_node_id,
+                    task_context=task_context,
+                    fields=field_updates,
+                )
             before_apply_status = ((task_context.get("record") or {}).get("apply_status"))
-            runtime_baseline = self._capture_task_runtime_baseline(
-                profile=profile,
-                context=context,
-                app_key=app_key,
-                record_id=record_id,
-                workflow_node_id=workflow_node_id,
-            )
+            runtime_baseline = None
+            if normalized_action != "save_only":
+                runtime_baseline = self._capture_task_runtime_baseline(
+                    profile=profile,
+                    context=context,
+                    app_key=app_key,
+                    record_id=record_id,
+                    workflow_node_id=workflow_node_id,
+                )
             try:
                 raw = self._execute_task_action(
                     profile=profile,
@@ -280,6 +334,7 @@ class TaskContextTools(ToolBase):
                     workflow_node_id=workflow_node_id,
                     normalized_action=normalized_action,
                     payload=body,
+                    prepared_fields=prepared_fields,
                 )
             except QingflowApiError as error:
                 if error.backend_code == 46001:
@@ -296,24 +351,39 @@ class TaskContextTools(ToolBase):
                     )
                 raise
 
-            verification, warnings = self._verify_task_action_runtime(
-                profile=profile,
-                context=context,
-                app_key=app_key,
-                record_id=record_id,
-                workflow_node_id=workflow_node_id,
-                action=normalized_action,
-                before_apply_status=before_apply_status,
-                runtime_baseline=runtime_baseline,
-            )
-            runtime_verified = bool(verification.get("runtime_continuation_verified"))
-            status = "success" if runtime_verified else "partial_success"
+            if normalized_action == "save_only":
+                verification, warnings = self._verify_task_save_only(
+                    context=context,
+                    app_key=app_key,
+                    record_id=record_id,
+                    workflow_node_id=workflow_node_id,
+                    before_apply_status=before_apply_status,
+                    expected_answers=((prepared_fields or {}).get("normalized_answers") or []),
+                    task_context=task_context,
+                )
+                save_verified = bool(verification.get("fields_saved_verified")) and bool(verification.get("task_still_actionable"))
+                status = "success" if save_verified else "failed"
+                error_code = None if save_verified else "TASK_SAVE_ONLY_VERIFICATION_FAILED"
+            else:
+                verification, warnings = self._verify_task_action_runtime(
+                    profile=profile,
+                    context=context,
+                    app_key=app_key,
+                    record_id=record_id,
+                    workflow_node_id=workflow_node_id,
+                    action=normalized_action,
+                    before_apply_status=before_apply_status,
+                    runtime_baseline=runtime_baseline,
+                )
+                runtime_verified = bool(verification.get("runtime_continuation_verified"))
+                status = "success" if runtime_verified else "partial_success"
+                error_code = None if runtime_verified else "WORKFLOW_CONTINUATION_UNVERIFIED"
             return {
                 "profile": raw.get("profile", profile),
                 "ws_id": raw.get("ws_id", session_profile.selected_ws_id),
-                "ok": bool(raw.get("ok", True)),
+                "ok": bool(raw.get("ok", True)) and status != "failed",
                 "status": status,
-                "error_code": None if runtime_verified else "WORKFLOW_CONTINUATION_UNVERIFIED",
+                "error_code": error_code,
                 "request_route": raw.get("request_route") or self._request_route_payload(context),
                 "warnings": warnings,
                 "verification": verification,
@@ -328,6 +398,7 @@ class TaskContextTools(ToolBase):
                     "selection": {"action": normalized_action},
                     "result": raw.get("result"),
                     "human_review": True,
+                    "field_update_applied": bool(field_updates),
                 },
             }
 
@@ -342,10 +413,18 @@ class TaskContextTools(ToolBase):
         workflow_node_id: int,
         normalized_action: str,
         payload: dict[str, Any],
+        prepared_fields: dict[str, Any] | None,
     ) -> dict[str, Any]:
+        merged_answers = None
+        if isinstance(prepared_fields, dict):
+            candidate_answers = prepared_fields.get("merged_answers")
+            if isinstance(candidate_answers, list):
+                merged_answers = candidate_answers
         if normalized_action == "approve":
             action_payload = dict(payload)
             action_payload["nodeId"] = workflow_node_id
+            if merged_answers is not None:
+                action_payload["answers"] = merged_answers
             return self._approval_tools.record_approve(
                 profile=profile,
                 app_key=app_key,
@@ -355,6 +434,8 @@ class TaskContextTools(ToolBase):
         if normalized_action == "reject":
             action_payload = dict(payload)
             action_payload["nodeId"] = workflow_node_id
+            if merged_answers is not None:
+                action_payload["answers"] = merged_answers
             if not self._extract_audit_feedback(action_payload):
                 raise_tool_error(QingflowApiError.config_error("payload.audit_feedback is required for reject"))
             return self._approval_tools.record_reject(
@@ -372,6 +453,8 @@ class TaskContextTools(ToolBase):
             audit_feedback = self._extract_audit_feedback(payload)
             if audit_feedback:
                 action_payload["auditFeedback"] = audit_feedback
+            if merged_answers is not None:
+                action_payload["answers"] = merged_answers
             return self._approval_tools.record_rollback(
                 profile=profile,
                 app_key=app_key,
@@ -387,12 +470,24 @@ class TaskContextTools(ToolBase):
             audit_feedback = self._extract_audit_feedback(payload)
             if audit_feedback:
                 action_payload["auditFeedback"] = audit_feedback
+            if merged_answers is not None:
+                action_payload["answers"] = merged_answers
             return self._approval_tools.record_transfer(
                 profile=profile,
                 app_key=app_key,
                 apply_id=record_id,
                 payload=action_payload,
             )
+        if normalized_action == "save_only":
+            if merged_answers is None:
+                raise_tool_error(QingflowApiError.config_error("fields is required for action 'save_only'"))
+            return self._task_save_only(
+                profile=profile,
+                app_key=app_key,
+                record_id=record_id,
+                workflow_node_id=workflow_node_id,
+                merged_answers=merged_answers,
+            )
         return self._task_tools.task_urge(
             profile=profile,
             app_key=app_key,
@@ -522,6 +617,121 @@ class TaskContextTools(ToolBase):
             )
         return verification, warnings
 
+    def _verify_task_save_only(
+        self,
+        *,
+        context: BackendRequestContext,
+        app_key: str,
+        record_id: int,
+        workflow_node_id: int,
+        before_apply_status: Any,
+        expected_answers: list[dict[str, Any]],
+        task_context: dict[str, Any],
+    ) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+        verification: dict[str, Any] = {
+            "action_executed": True,
+            "scope": "task_field_save",
+            "runtime_continuation_verified": False,
+            "task_context_visibility_verified": True,
+            "fields_saved_verified": False,
+            "task_still_actionable": False,
+            "workflow_not_advanced": False,
+            "before_apply_status": before_apply_status,
+        }
+        warnings: list[dict[str, Any]] = []
+        try:
+            detail = self.backend.request(
+                "GET",
+                context,
+                f"/app/{app_key}/apply/{record_id}",
+                params={"role": 3, "listType": 1, "auditNodeId": workflow_node_id},
+            )
+        except QingflowApiError as error:
+            verification["record_state_readable"] = False
+            verification["task_context_visibility_verified"] = False
+            verification["transport_error"] = {
+                "http_status": error.http_status,
+                "backend_code": error.backend_code,
+                "category": error.category,
+            }
+            warnings.append(
+                {
+                    "code": "TASK_SAVE_ONLY_UNVERIFIED",
+                    "message": "save_only write was sent, but MCP could not re-read the current task context to verify that the node remains actionable and fields were saved.",
+                }
+            )
+            return verification, warnings
+
+        verification["record_state_readable"] = True
+        verification["task_still_actionable"] = True
+        after_apply_status = detail.get("applyStatus") if isinstance(detail, dict) else None
+        verification["after_apply_status"] = after_apply_status
+        verification["workflow_not_advanced"] = after_apply_status == before_apply_status
+        current_record = task_context.get("record") if isinstance(task_context.get("record"), dict) else {}
+        actual_answers = detail.get("answers") if isinstance(detail, dict) and isinstance(detail.get("answers"), list) else []
+        expected_by_id = {
+            que_id: answer
+            for answer in expected_answers
+            if isinstance(answer, dict) and (que_id := _coerce_count(answer.get("queId"))) is not None and que_id > 0
+        }
+        actual_by_id = {
+            que_id: answer
+            for answer in actual_answers
+            if isinstance(answer, dict) and (que_id := _coerce_count(answer.get("queId"))) is not None and que_id > 0
+        }
+        update_schema = task_context.get("update_schema") if isinstance(task_context.get("update_schema"), dict) else {}
+        writable_titles = {
+            item.get("title"): item
+            for item in (update_schema.get("writable_fields") or [])
+            if isinstance(item, dict) and item.get("title")
+        }
+        missing_fields: list[dict[str, Any]] = []
+        mismatched_fields: list[dict[str, Any]] = []
+        for que_id, expected in expected_by_id.items():
+            actual = actual_by_id.get(que_id)
+            title = None
+            if isinstance(current_record, dict):
+                for answer in (current_record.get("answers") or []):
+                    if isinstance(answer, dict) and _coerce_count(answer.get("queId")) == que_id:
+                        title = answer.get("queTitle")
+                        break
+            if title is None:
+                title = next((key for key, item in writable_titles.items() if isinstance(item, dict) and item.get("field_id") == que_id), None)
+            field_payload = {"que_id": que_id, "que_title": title}
+            if actual is None:
+                missing_fields.append(field_payload)
+                continue
+            expected_value = _canonicalize_answer_value_for_compare(expected, None)
+            actual_value = _canonicalize_answer_value_for_compare(actual, None)
+            if _canonical_value_is_empty(expected_value):
+                continue
+            if actual_value != expected_value:
+                mismatched_fields.append(
+                    {
+                        **field_payload,
+                        "expected": expected_value,
+                        "actual": actual_value,
+                    }
+                )
+        verification["missing_fields"] = missing_fields
+        verification["mismatched_fields"] = mismatched_fields
+        verification["fields_saved_verified"] = not missing_fields and not mismatched_fields
+        if not verification["workflow_not_advanced"]:
+            warnings.append(
+                {
+                    "code": "TASK_SAVE_ONLY_ADVANCED_WORKFLOW",
+                    "message": "save_only unexpectedly changed the workflow runtime state; the task should have remained on the current node.",
+                }
+            )
+        if not verification["fields_saved_verified"]:
+            warnings.append(
+                {
+                    "code": "TASK_SAVE_ONLY_FIELD_VERIFICATION_FAILED",
+                    "message": "save_only completed, but MCP could not verify that all requested field changes were persisted on the current task node.",
+                }
+            )
+        return verification, warnings
+
     def _capture_task_runtime_baseline(
         self,
         *,
@@ -695,7 +905,8 @@ class TaskContextTools(ToolBase):
 
         def runner(session_profile, context):
             task_context = self._build_task_context(
-                context,
+                profile=profile,
+                context=context,
                 app_key=app_key,
                 record_id=record_id,
                 workflow_node_id=workflow_node_id,
@@ -876,7 +1087,8 @@ class TaskContextTools(ToolBase):
 
         def runner(session_profile, context):
             task_context = self._build_task_context(
-                context,
+                profile=profile,
+                context=context,
                 app_key=app_key,
                 record_id=record_id,
                 workflow_node_id=workflow_node_id,
@@ -929,6 +1141,7 @@ class TaskContextTools(ToolBase):
 
     def _build_task_context(
         self,
+        profile: str,
         context: BackendRequestContext,
         *,
         app_key: str,
@@ -987,7 +1200,20 @@ class TaskContextTools(ToolBase):
             )
             transfer_items = _approval_page_items(transfer_result)
 
-        capabilities = self._build_capabilities(node_info)
+        update_schema_state = self._build_task_update_schema(
+            profile=profile,
+            context=context,
+            app_key=app_key,
+            record_id=record_id,
+            workflow_node_id=workflow_node_id,
+            node_info=node_info,
+            current_answers=detail.get("answers") or [],
+        )
+        update_schema = update_schema_state["public_schema"]
+        capabilities = self._build_capabilities(
+            node_info,
+            allow_save_only=bool(update_schema.get("writable_fields")),
+        )
         visibility = self._build_visibility(node_info, detail)
         return {
             "task": {
@@ -997,6 +1223,11 @@ class TaskContextTools(ToolBase):
                 "workflow_node_name": node_info.get("auditNodeName") or node_info.get("nodeName"),
                 "actionable": True,
             },
+            "node": {
+                "workflow_node_id": workflow_node_id,
+                "workflow_node_name": node_info.get("auditNodeName") or node_info.get("nodeName"),
+                "raw": dict(node_info),
+            },
             "record": {
                 "apply_id": detail.get("applyId", record_id),
                 "apply_status": detail.get("applyStatus"),
@@ -1010,6 +1241,8 @@ class TaskContextTools(ToolBase):
             "capabilities": capabilities,
             "field_permissions": {
                 "que_auth_setting": node_info.get("queAuthSetting") or [],
+                "editable_question_ids": update_schema_state["editable_question_ids"],
+                "editable_question_ids_source": update_schema_state["editable_question_ids_source"],
             },
             "visibility": visibility,
             "associated_reports": associated_reports,
@@ -1023,6 +1256,7 @@ class TaskContextTools(ToolBase):
                 "history_count": None,
                 "qrobot_log_visible": visibility["qrobot_record_visible"],
             },
+            "update_schema": update_schema,
         }
 
     def _normalize_task_item(self, raw: dict[str, Any], *, task_box: str, flow_status: str) -> dict[str, Any]:
@@ -1071,7 +1305,7 @@ class TaskContextTools(ToolBase):
             )
         )
 
-    def _build_capabilities(self, node_info: dict[str, Any]) -> dict[str, Any]:
+    def _build_capabilities(self, node_info: dict[str, Any], *, allow_save_only: bool) -> dict[str, Any]:
         available_actions = ["approve"]
         if self._coerce_bool(node_info.get("rejectBtnStatus")):
             available_actions.append("reject")
@@ -1081,6 +1315,8 @@ class TaskContextTools(ToolBase):
             available_actions.append("transfer")
         if self._coerce_bool(node_info.get("canUrge")):
             available_actions.append("urge")
+        if allow_save_only:
+            available_actions.append("save_only")
 
         visible_but_unimplemented_actions: list[str] = []
         if self._coerce_bool(node_info.get("canRevoke")):
@@ -1107,6 +1343,362 @@ class TaskContextTools(ToolBase):
             },
         }
 
+    def _build_task_update_schema(
+        self,
+        profile: str,
+        context: BackendRequestContext,
+        *,
+        app_key: str,
+        record_id: int,
+        workflow_node_id: int,
+        node_info: dict[str, Any],
+        current_answers: Any,
+    ) -> dict[str, Any]:
+        try:
+            app_schema = self._record_tools._get_form_schema(profile, context, app_key, force_refresh=False)
+        except QingflowApiError as error:
+            public_schema: JSONObject = {
+                "schema_scope": "task_update_ready",
+                "writable_fields": [],
+                "payload_template": {},
+                "blockers": ["TASK_UPDATE_SCHEMA_UNAVAILABLE"],
+                "warnings": [
+                    {
+                        "code": "TASK_UPDATE_SCHEMA_UNAVAILABLE",
+                        "message": "task detail could not load the form schema for the current app, so node-scoped update schema is unavailable.",
+                    }
+                ],
+                "selection": {
+                    "app_key": app_key,
+                    "record_id": record_id,
+                    "workflow_node_id": workflow_node_id,
+                },
+                "transport_error": {
+                    "http_status": error.http_status,
+                    "backend_code": error.backend_code,
+                    "category": error.category,
+                },
+            }
+            return {
+                "public_schema": public_schema,
+                "index": None,
+                "editable_question_ids": [],
+                "effective_editable_question_ids": [],
+                "editable_question_ids_source": "schema_unavailable",
+            }
+
+        question_relations = _collect_question_relations(app_schema)
+        linked_field_ids = _collect_linked_required_field_ids(question_relations)
+        base_index = _build_applicant_top_level_field_index(app_schema)
+        linked_field_ids.update(_collect_option_linked_field_ids(base_index))
+        linked_hidden_index = _build_applicant_hidden_linked_top_level_field_index(
+            app_schema,
+            linked_field_ids=linked_field_ids,
+        )
+        index = _merge_field_indexes(base_index, linked_hidden_index)
+        editable_question_ids, schema_warnings, source = self._resolve_task_editable_question_ids(
+            context,
+            app_key=app_key,
+            workflow_node_id=workflow_node_id,
+            node_info=node_info,
+        )
+        effective_editable_ids = set(editable_question_ids)
+        for field in index.by_id.values():
+            if field.que_type in SUBTABLE_QUE_TYPES and (_subtable_descendant_ids(field) & set(editable_question_ids)):
+                effective_editable_ids.add(field.que_id)
+        writable_fields: list[JSONObject] = []
+        linkage_payloads_by_field_id = _build_static_schema_linkage_payloads(
+            index=index,
+            question_relations=question_relations,
+        )
+        for field in index.by_id.values():
+            if field.que_type in LAYOUT_ONLY_QUE_TYPES or field.que_id not in effective_editable_ids:
+                continue
+            editable_field = _clone_form_field(field, readonly=False)
+            write_hints = self._record_tools._schema_write_hints(editable_field)
+            if not bool(write_hints.get("writable")):
+                continue
+            writable_fields.append(
+                self._record_tools._ready_schema_field_payload(
+                    profile,
+                    context,
+                    editable_field,
+                    ws_id=context.ws_id,
+                    required_override=False,
+                    linkage_payloads_by_field_id=linkage_payloads_by_field_id,
+                )
+            )
+        blockers: list[str] = []
+        if not writable_fields:
+            blockers.append("NO_TASK_EDITABLE_FIELDS")
+            schema_warnings.append(
+                {
+                    "code": "NO_TASK_EDITABLE_FIELDS",
+                    "message": "the current task node does not expose any writable fields for task-scoped edits.",
+                }
+            )
+        public_schema: JSONObject = {
+            "schema_scope": "task_update_ready",
+            "writable_fields": writable_fields,
+            "payload_template": {
+                item["title"]: self._record_tools._ready_schema_template_value(item)
+                for item in writable_fields
+                if isinstance(item, dict) and item.get("title")
+            },
+            "blockers": blockers,
+            "warnings": schema_warnings,
+            "selection": {
+                "app_key": app_key,
+                "record_id": record_id,
+                "workflow_node_id": workflow_node_id,
+            },
+        }
+        return {
+            "public_schema": public_schema,
+            "index": index,
+            "editable_question_ids": sorted(editable_question_ids),
+            "effective_editable_question_ids": sorted(effective_editable_ids),
+            "editable_question_ids_source": source,
+        }
+
+    def _resolve_task_editable_question_ids(
+        self,
+        context: BackendRequestContext,
+        *,
+        app_key: str,
+        workflow_node_id: int,
+        node_info: dict[str, Any],
+    ) -> tuple[set[int], list[JSONObject], str]:
+        warnings: list[JSONObject] = []
+        try:
+            payload = self.backend.request(
+                "GET",
+                context,
+                f"/app/{app_key}/auditNode/{workflow_node_id}/editableQueIds",
+            )
+            question_ids = self._extract_question_ids(payload)
+            if question_ids:
+                return question_ids, warnings, "workflow_editable_que_ids"
+        except QingflowApiError as error:
+            if error.backend_code not in {40002, 40027, 404} and error.http_status != 404:
+                raise
+            warnings.append(
+                {
+                    "code": "TASK_EDITABLE_IDS_FALLBACK",
+                    "message": "editable question ids endpoint is unavailable in the current route; task update schema fell back to queAuthSetting and may be conservative.",
+                }
+            )
+        fallback_ids = self._editable_ids_from_que_auth_setting(node_info.get("queAuthSetting"))
+        return fallback_ids, warnings, "que_auth_setting"
+
+    def _extract_question_ids(self, payload: Any) -> set[int]:
+        candidates: list[Any] = []
+        if isinstance(payload, list):
+            candidates = payload
+        elif isinstance(payload, dict):
+            for key in ("editableQueIds", "editableQuestionIds", "queIds", "questionIds", "ids", "list", "result"):
+                value = payload.get(key)
+                if isinstance(value, list):
+                    candidates = value
+                    break
+        question_ids: set[int] = set()
+        for item in candidates:
+            if isinstance(item, int) and item > 0:
+                question_ids.add(item)
+                continue
+            if isinstance(item, dict):
+                for key in ("queId", "questionId", "id"):
+                    value = _coerce_count(item.get(key))
+                    if value is not None and value > 0:
+                        question_ids.add(value)
+                        break
+        return question_ids
+
+    def _editable_ids_from_que_auth_setting(self, payload: Any) -> set[int]:
+        if not isinstance(payload, list):
+            return set()
+        editable_ids: set[int] = set()
+        for item in payload:
+            if not isinstance(item, dict):
+                continue
+            que_id = _coerce_count(item.get("queId") or item.get("questionId"))
+            if que_id is None or que_id <= 0:
+                continue
+            explicit_editable_keys = ("editable", "writable", "canEdit", "editStatus", "beingEditable")
+            explicit_readonly_keys = ("readonly", "beingReadonly")
+            if any(key in item for key in explicit_editable_keys):
+                if any(bool(item.get(key)) for key in explicit_editable_keys):
+                    editable_ids.add(que_id)
+                continue
+            if any(bool(item.get(key)) for key in explicit_readonly_keys):
+                continue
+            if item.get("readable") is False:
+                continue
+            if item.get("readable") is True or item.get("visible") is True:
+                editable_ids.add(que_id)
+        return editable_ids
+
+    def _prepare_task_field_update(
+        self,
+        *,
+        profile: str,
+        context: BackendRequestContext,
+        app_key: str,
+        record_id: int,
+        workflow_node_id: int,
+        task_context: dict[str, Any],
+        fields: dict[str, Any],
+    ) -> dict[str, Any]:
+        record = task_context.get("record") if isinstance(task_context.get("record"), dict) else {}
+        current_answers = record.get("answers") if isinstance(record.get("answers"), list) else []
+        node = task_context.get("node") if isinstance(task_context.get("node"), dict) else {}
+        node_info = node.get("raw") if isinstance(node.get("raw"), dict) else {}
+        schema_state = self._build_task_update_schema(
+            profile=profile,
+            context=context,
+            app_key=app_key,
+            record_id=record_id,
+            workflow_node_id=workflow_node_id,
+            node_info=node_info,
+            current_answers=current_answers,
+        )
+        update_schema = schema_state["public_schema"]
+        if update_schema.get("blockers"):
+            raise_tool_error(
+                QingflowApiError(
+                    category="config",
+                    message="task field update is blocked because the current node does not expose a usable update schema",
+                    details={
+                        "error_code": "TASK_UPDATE_SCHEMA_BLOCKED",
+                        "update_schema": update_schema,
+                    },
+                )
+            )
+        preflight = self._record_tools._build_record_write_preflight(
+            profile=profile,
+            context=context,
+            operation="update",
+            app_key=app_key,
+            apply_id=record_id,
+            answers=[],
+            fields=fields,
+            force_refresh_form=False,
+            view_id=None,
+            list_type=None,
+            view_key=None,
+            view_name=None,
+            existing_answers_override=current_answers,
+        )
+        index = schema_state["index"]
+        effective_editable_ids = set(schema_state["effective_editable_question_ids"])
+        scoped_field_errors = self._task_scope_field_errors(
+            normalized_answers=preflight.get("normalized_answers") or [],
+            index=index,
+            effective_editable_ids=effective_editable_ids,
+        )
+        field_errors = list(preflight.get("field_errors") or [])
+        field_errors.extend(scoped_field_errors)
+        blockers = list(preflight.get("blockers") or [])
+        if scoped_field_errors:
+            blockers.append("payload writes fields that are not editable on the current task node")
+        confirmation_requests = list(preflight.get("confirmation_requests") or [])
+        if field_errors or confirmation_requests or blockers:
+            raise_tool_error(
+                QingflowApiError(
+                    category="config",
+                    message="task field update preflight was blocked",
+                    details={
+                        "error_code": "TASK_FIELD_PLAN_BLOCKED",
+                        "blockers": blockers,
+                        "field_errors": field_errors,
+                        "confirmation_requests": confirmation_requests,
+                        "update_schema": update_schema,
+                        "recommended_next_actions": preflight.get("recommended_next_actions") or [],
+                    },
+                )
+            )
+        normalized_answers = [item for item in (preflight.get("normalized_answers") or []) if isinstance(item, dict)]
+        merged_answers = self._record_tools._merge_record_answers(current_answers, normalized_answers)
+        return {
+            "update_schema": update_schema,
+            "normalized_answers": normalized_answers,
+            "merged_answers": merged_answers,
+        }
+
+    def _task_scope_field_errors(
+        self,
+        *,
+        normalized_answers: list[dict[str, Any]],
+        index: Any,
+        effective_editable_ids: set[int],
+    ) -> list[dict[str, Any]]:
+        if index is None:
+            return []
+        field_errors: list[dict[str, Any]] = []
+        for answer in normalized_answers:
+            que_id = _coerce_count(answer.get("queId"))
+            if que_id is None or que_id <= 0:
+                continue
+            field = index.by_id.get(str(que_id))
+            field_payload = _field_ref_payload(field) if field is not None else {"que_id": que_id}
+            if que_id not in effective_editable_ids:
+                field_errors.append(
+                    {
+                        "location": field.que_title if field is not None else str(que_id),
+                        "message": "field is not editable on the current task node",
+                        "error_code": "TASK_FIELD_NOT_EDITABLE",
+                        "field": field_payload,
+                    }
+                )
+                continue
+            if field is None or field.que_type not in SUBTABLE_QUE_TYPES:
+                continue
+            table_values = answer.get("tableValues") if isinstance(answer.get("tableValues"), list) else []
+            subtable_index = self._record_tools._subtable_field_index_optional(field)
+            for row_ordinal, row in enumerate(table_values, start=1):
+                row_cells = [item for item in row if isinstance(item, dict)] if isinstance(row, list) else []
+                for cell in row_cells:
+                    cell_que_id = _coerce_count(cell.get("queId"))
+                    if cell_que_id is None or cell_que_id <= 0 or cell_que_id in effective_editable_ids:
+                        continue
+                    subfield = subtable_index.by_id.get(str(cell_que_id)) if subtable_index is not None else None
+                    field_errors.append(
+                        {
+                            "location": f"{field.que_title}[{row_ordinal}].{subfield.que_title if subfield is not None else cell_que_id}",
+                            "message": "subtable field is not editable on the current task node",
+                            "error_code": "TASK_FIELD_NOT_EDITABLE",
+                            "field": _field_ref_payload(subfield) if subfield is not None else {"que_id": cell_que_id},
+                        }
+                    )
+        return field_errors
+
+    def _task_save_only(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int,
+        workflow_node_id: int,
+        merged_answers: list[dict[str, Any]],
+    ) -> dict[str, Any]:
+        def runner(session_profile, context):
+            result = self.backend.request(
+                "POST",
+                context,
+                f"/app/{app_key}/apply/{record_id}",
+                json_body={"role": 3, "auditNodeId": workflow_node_id, "answers": merged_answers},
+            )
+            return {
+                "profile": profile,
+                "ws_id": session_profile.selected_ws_id,
+                "app_key": app_key,
+                "apply_id": record_id,
+                "result": result,
+                "request_route": self._request_route_payload(context),
+            }
+
+        return self._run(profile, runner)
+
     def _build_visibility(self, node_info: dict[str, Any], detail: dict[str, Any]) -> dict[str, bool]:
         return {
             "comment_visible": self._coerce_bool(node_info.get("commentStatus")),