@josephyan/qingflow-app-builder-mcp 0.2.0-beta.7 → 0.2.0-beta.71

package/src/qingflow_mcp/tools/task_context_tools.py

@@ -0,0 +1,2040 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+from uuid import uuid4
+
+from mcp.server.fastmcp import FastMCP
+
+from ..backend_client import BackendRequestContext
+from ..config import DEFAULT_PROFILE
+from ..errors import QingflowApiError, raise_tool_error
+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
+
+
+class TaskContextTools(ToolBase):
+    def __init__(self, sessions, backend) -> None:  # type: ignore[no-untyped-def]
+        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()
+        def task_list(
+            profile: str = DEFAULT_PROFILE,
+            task_box: str = "todo",
+            flow_status: str = "all",
+            app_key: str | None = None,
+            workflow_node_id: int | None = None,
+            query: str | None = None,
+            page: int = 1,
+            page_size: int = 20,
+        ) -> dict[str, Any]:
+            return self.task_list(
+                profile=profile,
+                task_box=task_box,
+                flow_status=flow_status,
+                app_key=app_key,
+                workflow_node_id=workflow_node_id,
+                query=query,
+                page=page,
+                page_size=page_size,
+            )
+
+        @mcp.tool()
+        def task_get(
+            profile: str = DEFAULT_PROFILE,
+            app_key: str = "",
+            record_id: int = 0,
+            workflow_node_id: int = 0,
+            include_candidates: bool = True,
+            include_associated_reports: bool = True,
+        ) -> dict[str, Any]:
+            return self.task_get(
+                profile=profile,
+                app_key=app_key,
+                record_id=record_id,
+                workflow_node_id=workflow_node_id,
+                include_candidates=include_candidates,
+                include_associated_reports=include_associated_reports,
+            )
+
+        @mcp.tool(description=self._high_risk_tool_description(operation="execute", target="workflow task action"))
+        def task_action_execute(
+            profile: str = DEFAULT_PROFILE,
+            app_key: str = "",
+            record_id: int = 0,
+            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,
+                app_key=app_key,
+                record_id=record_id,
+                workflow_node_id=workflow_node_id,
+                action=action,
+                payload=payload or {},
+                fields=fields or {},
+            )
+
+        @mcp.tool()
+        def task_associated_report_detail_get(
+            profile: str = DEFAULT_PROFILE,
+            app_key: str = "",
+            record_id: int = 0,
+            workflow_node_id: int = 0,
+            report_id: int = 0,
+            page: int = 1,
+            page_size: int = 20,
+        ) -> dict[str, Any]:
+            return self.task_associated_report_detail_get(
+                profile=profile,
+                app_key=app_key,
+                record_id=record_id,
+                workflow_node_id=workflow_node_id,
+                report_id=report_id,
+                page=page,
+                page_size=page_size,
+            )
+
+        @mcp.tool()
+        def task_workflow_log_get(
+            profile: str = DEFAULT_PROFILE,
+            app_key: str = "",
+            record_id: int = 0,
+            workflow_node_id: int = 0,
+        ) -> dict[str, Any]:
+            return self.task_workflow_log_get(
+                profile=profile,
+                app_key=app_key,
+                record_id=record_id,
+                workflow_node_id=workflow_node_id,
+            )
+
+    def task_list(
+        self,
+        *,
+        profile: str,
+        task_box: str,
+        flow_status: str,
+        app_key: str | None,
+        workflow_node_id: int | None,
+        query: str | None,
+        page: int,
+        page_size: int,
+    ) -> dict[str, Any]:
+        normalized_type = self._task_tools._task_box_to_type(task_box)
+        normalized_status = self._task_tools._flow_status_to_process_status(flow_status)
+        raw = self._task_tools.task_list(
+            profile=profile,
+            type=normalized_type,
+            process_status=normalized_status,
+            app_key=app_key,
+            node_id=workflow_node_id,
+            search_key=query,
+            page_num=page,
+            page_size=page_size,
+            create_time_asc=None,
+        )
+        task_page = raw.get("page", {})
+        items = [
+            self._normalize_task_item(item, task_box=task_box, flow_status=flow_status)
+            for item in _task_page_items(task_page)
+            if isinstance(item, dict)
+        ]
+        return {
+            "profile": profile,
+            "ws_id": raw.get("ws_id"),
+            "ok": True,
+            "request_route": raw.get("request_route"),
+            "warnings": [],
+            "output_profile": "normal",
+            "data": {
+                "items": items,
+                "pagination": {
+                    "page": page,
+                    "page_size": page_size,
+                    "returned_items": len(items),
+                    "page_amount": _task_page_amount(task_page),
+                    "reported_total": _task_page_total(task_page),
+                },
+                "selection": {
+                    "task_box": task_box,
+                    "flow_status": flow_status,
+                    "app_key": app_key,
+                    "workflow_node_id": workflow_node_id,
+                    "query": query,
+                },
+            },
+        }
+
+    def task_get(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int,
+        workflow_node_id: int,
+        include_candidates: bool,
+        include_associated_reports: bool,
+    ) -> dict[str, Any]:
+        self._require_app_record_and_node(app_key, record_id, workflow_node_id)
+
+        def runner(session_profile, context):
+            data = self._build_task_context(
+                profile=profile,
+                context=context,
+                app_key=app_key,
+                record_id=record_id,
+                workflow_node_id=workflow_node_id,
+                include_candidates=include_candidates,
+                include_associated_reports=include_associated_reports,
+                current_uid=session_profile.uid,
+            )
+            return {
+                "profile": profile,
+                "ws_id": session_profile.selected_ws_id,
+                "ok": True,
+                "request_route": self._request_route_payload(context),
+                "warnings": [],
+                "output_profile": "normal",
+                "data": data,
+            }
+
+        return self._run(profile, runner)
+
+    def task_action_execute(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int,
+        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", "save_only"}:
+            raise_tool_error(
+                QingflowApiError.not_supported(
+                    "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(
+                    profile=profile,
+                    context=context,
+                    app_key=app_key,
+                    record_id=record_id,
+                    workflow_node_id=workflow_node_id,
+                    include_candidates=False,
+                    include_associated_reports=False,
+                    current_uid=session_profile.uid,
+                )
+            except QingflowApiError as error:
+                if error.backend_code == 46001:
+                    return self._task_action_visibility_unverified_response(
+                        profile=profile,
+                        session_profile=session_profile,
+                        context=context,
+                        app_key=app_key,
+                        record_id=record_id,
+                        workflow_node_id=workflow_node_id,
+                        action=normalized_action,
+                        source_error=error,
+                        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'")
+                )
+            if normalized_action == "transfer":
+                target_member_id = self._extract_positive_int(body, "target_member_id", aliases=("uid", "targetMemberId"))
+                if target_member_id == session_profile.uid:
+                    raise_tool_error(
+                        QingflowApiError.config_error(
+                            "task transfer does not support transferring to the current user; choose another transfer member"
+                        )
+                    )
+            capabilities = task_context.get("capabilities") or {}
+            available_actions = capabilities.get("available_actions") or []
+            if normalized_action not in available_actions:
+                raise_tool_error(
+                    QingflowApiError.config_error(
+                        f"task action '{normalized_action}' is not currently available for app_key='{app_key}' record_id={record_id} workflow_node_id={workflow_node_id}"
+                    )
+                )
+            feedback_required_for = capabilities.get("action_constraints", {}).get("feedback_required_for") or []
+            if normalized_action in feedback_required_for and not self._extract_audit_feedback(body):
+                raise_tool_error(
+                    QingflowApiError.config_error(
+                        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 = 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,
+                    app_key=app_key,
+                    record_id=record_id,
+                    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:
+                    return self._task_action_visibility_unverified_response(
+                        profile=profile,
+                        session_profile=session_profile,
+                        context=context,
+                        app_key=app_key,
+                        record_id=record_id,
+                        workflow_node_id=workflow_node_id,
+                        action=normalized_action,
+                        source_error=error,
+                        before_apply_status=before_apply_status,
+                    )
+                raise
+
+            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)) and status != "failed",
+                "status": status,
+                "error_code": error_code,
+                "request_route": raw.get("request_route") or self._request_route_payload(context),
+                "warnings": warnings,
+                "verification": verification,
+                "output_profile": "normal",
+                "data": {
+                    "action": normalized_action,
+                    "resource": {
+                        "app_key": app_key,
+                        "record_id": record_id,
+                        "workflow_node_id": workflow_node_id,
+                    },
+                    "selection": {"action": normalized_action},
+                    "result": raw.get("result"),
+                    "human_review": True,
+                    "field_update_applied": bool(field_updates),
+                },
+            }
+
+        return self._run(profile, runner)
+
+    def _execute_task_action(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int,
+        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,
+                apply_id=record_id,
+                payload=action_payload,
+            )
+        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(
+                profile=profile,
+                app_key=app_key,
+                apply_id=record_id,
+                payload=action_payload,
+            )
+        if normalized_action == "rollback":
+            target_node_id = self._extract_positive_int(payload, "target_workflow_node_id", aliases=("targetAuditNodeId", "targetWorkflowNodeId"))
+            action_payload: JSONObject = {
+                "auditNodeId": workflow_node_id,
+                "targetAuditNodeId": target_node_id,
+            }
+            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,
+                apply_id=record_id,
+                payload=action_payload,
+            )
+        if normalized_action == "transfer":
+            target_member_id = self._extract_positive_int(payload, "target_member_id", aliases=("uid", "targetMemberId"))
+            action_payload = {
+                "auditNodeId": workflow_node_id,
+                "uid": target_member_id,
+            }
+            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,
+            row_record_id=record_id,
+        )
+
+    def _verify_task_action_runtime(
+        self,
+        *,
+        profile: str,
+        context: BackendRequestContext,
+        app_key: str,
+        record_id: int,
+        workflow_node_id: int,
+        action: str,
+        before_apply_status: Any,
+        runtime_baseline: dict[str, Any] | None = None,
+    ) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+        verification: dict[str, Any] = {
+            "action_executed": True,
+            "runtime_continuation_verified": action == "urge",
+            "scope": "workflow_runtime",
+            "task_context_visibility_verified": True,
+        }
+        warnings: list[dict[str, Any]] = []
+        if action == "urge":
+            return verification, warnings
+
+        state_after: dict[str, Any] | None = None
+        try:
+            state_after = self.backend.request(
+                "GET",
+                context,
+                f"/app/{app_key}/apply/{record_id}",
+                params={"role": 3, "listType": 1, "auditNodeId": workflow_node_id},
+            )
+            verification["record_state_readable"] = True
+            verification["before_apply_status"] = before_apply_status
+            verification["after_apply_status"] = state_after.get("applyStatus") if isinstance(state_after, dict) else None
+            verification["record_state_changed"] = verification["after_apply_status"] != before_apply_status
+        except QingflowApiError as error:
+            verification["record_state_readable"] = False
+            verification["record_state_changed"] = False
+            verification["record_state_error"] = {
+                "http_status": error.http_status,
+                "backend_code": error.backend_code,
+                "category": error.category,
+            }
+
+        log_items: list[dict[str, Any]] = []
+        try:
+            log_page = self.backend.request(
+                "POST",
+                context,
+                "/application/workflow/node/record",
+                json_body={
+                    "key": app_key,
+                    "rowRecordId": record_id,
+                    "nodeId": workflow_node_id,
+                    "role": 3,
+                    "pageNum": 1,
+                    "pageSize": 50,
+                },
+            )
+            log_items = self._normalize_workflow_logs(log_page)
+            verification["workflow_log_visible"] = True
+            verification["workflow_log_count"] = len(log_items)
+        except QingflowApiError as error:
+            verification["workflow_log_visible"] = False
+            verification["workflow_log_count"] = None
+            verification["workflow_log_error"] = {
+                "http_status": error.http_status,
+                "backend_code": error.backend_code,
+                "category": error.category,
+            }
+
+        todo_items = self._safe_task_list_items(profile=profile, task_box="todo", app_key=app_key)
+        initiated_items = self._safe_task_list_items(profile=profile, task_box="initiated", app_key=app_key)
+        downstream_todo_detected = any(
+            int(item.get("record_id") or 0) == record_id and int(item.get("workflow_node_id") or 0) != workflow_node_id
+            for item in todo_items
+            if isinstance(item, dict)
+        )
+        initiated_visible = any(
+            int(item.get("record_id") or 0) == record_id
+            for item in initiated_items
+            if isinstance(item, dict)
+        )
+        verification["downstream_todo_detected"] = downstream_todo_detected
+        verification["initiated_task_visible"] = initiated_visible
+        baseline_downstream_nodes = set()
+        baseline_log_count = None
+        baseline_log_digest = None
+        if isinstance(runtime_baseline, dict):
+            baseline_downstream_nodes = set(runtime_baseline.get("downstream_todo_nodes") or [])
+            baseline_log_count = runtime_baseline.get("workflow_log_count")
+            baseline_log_digest = runtime_baseline.get("workflow_log_digest")
+        current_downstream_nodes = {
+            int(item.get("workflow_node_id") or 0)
+            for item in todo_items
+            if isinstance(item, dict)
+            and int(item.get("record_id") or 0) == record_id
+            and int(item.get("workflow_node_id") or 0) != workflow_node_id
+        }
+        workflow_log_digest = self._workflow_log_digest(log_items)
+        verification["downstream_todo_nodes"] = sorted(node_id for node_id in current_downstream_nodes if node_id > 0)
+        verification["downstream_todo_changed"] = current_downstream_nodes != baseline_downstream_nodes
+        verification["workflow_log_advanced"] = bool(
+            verification.get("workflow_log_visible")
+            and (
+                (isinstance(baseline_log_count, int) and len(log_items) > baseline_log_count)
+                or (baseline_log_digest is not None and workflow_log_digest is not None and workflow_log_digest != baseline_log_digest)
+            )
+        )
+        runtime_verified = bool(
+            verification.get("record_state_changed")
+            or verification.get("downstream_todo_changed")
+            or verification.get("workflow_log_advanced")
+        )
+        verification["runtime_continuation_verified"] = runtime_verified
+        if not runtime_verified:
+            warnings.append(
+                {
+                    "code": "WORKFLOW_CONTINUATION_UNVERIFIED",
+                    "message": "task action executed, but MCP could not verify downstream workflow continuation from record state, workflow logs, or downstream todo tasks.",
+                }
+            )
+        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,
+        *,
+        profile: str,
+        context: BackendRequestContext,
+        app_key: str,
+        record_id: int,
+        workflow_node_id: int,
+    ) -> dict[str, Any]:
+        baseline: dict[str, Any] = {
+            "workflow_log_visible": False,
+            "workflow_log_count": None,
+            "workflow_log_digest": None,
+            "downstream_todo_nodes": [],
+        }
+        try:
+            log_page = self.backend.request(
+                "POST",
+                context,
+                "/application/workflow/node/record",
+                json_body={
+                    "key": app_key,
+                    "rowRecordId": record_id,
+                    "nodeId": workflow_node_id,
+                    "role": 3,
+                    "pageNum": 1,
+                    "pageSize": 50,
+                },
+            )
+            log_items = self._normalize_workflow_logs(log_page)
+            baseline["workflow_log_visible"] = True
+            baseline["workflow_log_count"] = len(log_items)
+            baseline["workflow_log_digest"] = self._workflow_log_digest(log_items)
+        except QingflowApiError:
+            pass
+        todo_items = self._safe_task_list_items(profile=profile, task_box="todo", app_key=app_key)
+        baseline["downstream_todo_nodes"] = sorted(
+            {
+                int(item.get("workflow_node_id") or 0)
+                for item in todo_items
+                if isinstance(item, dict)
+                and int(item.get("record_id") or 0) == record_id
+                and int(item.get("workflow_node_id") or 0) != workflow_node_id
+            }
+        )
+        return baseline
+
+    def _task_action_visibility_unverified_response(
+        self,
+        *,
+        profile: str,
+        session_profile,
+        context: BackendRequestContext,
+        app_key: str,
+        record_id: int,
+        workflow_node_id: int,
+        action: str,
+        source_error: QingflowApiError,
+        before_apply_status: Any,
+    ) -> dict[str, Any]:
+        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=action,
+            before_apply_status=before_apply_status,
+        )
+        verification["action_executed"] = False
+        verification["task_context_visibility_verified"] = bool(verification.get("runtime_continuation_verified"))
+        if verification["task_context_visibility_verified"]:
+            warnings.append(
+                {
+                    "code": "TASK_ALREADY_PROCESSED_UNCONFIRMED_ACTOR",
+                    "message": "the task is no longer actionable in the current context; MCP found downstream workflow evidence and treats it as already processed by another actor.",
+                }
+            )
+            return {
+                "profile": profile,
+                "ws_id": session_profile.selected_ws_id,
+                "ok": True,
+                "status": "partial_success",
+                "error_code": "TASK_ALREADY_PROCESSED",
+                "request_route": self._request_route_payload(context),
+                "warnings": warnings,
+                "verification": verification,
+                "output_profile": "normal",
+                "data": {
+                    "action": action,
+                    "resource": {
+                        "app_key": app_key,
+                        "record_id": record_id,
+                        "workflow_node_id": workflow_node_id,
+                    },
+                    "selection": {"action": action},
+                    "result": None,
+                    "human_review": True,
+                },
+            }
+        warnings.append(
+            {
+                "code": "TASK_CONTEXT_VISIBILITY_UNVERIFIED",
+                "message": "the task is no longer actionable, and MCP could not verify from state or workflow logs whether it was already processed.",
+            }
+        )
+        return {
+            "profile": profile,
+            "ws_id": session_profile.selected_ws_id,
+            "ok": False,
+            "status": "failed",
+            "error_code": "TASK_CONTEXT_VISIBILITY_UNVERIFIED",
+            "request_route": self._request_route_payload(context),
+            "warnings": warnings,
+            "verification": verification,
+            "output_profile": "normal",
+            "data": {
+                "action": action,
+                "resource": {
+                    "app_key": app_key,
+                    "record_id": record_id,
+                    "workflow_node_id": workflow_node_id,
+                },
+                "selection": {"action": action},
+                "result": None,
+                "human_review": True,
+                "transport_error": {
+                    "http_status": source_error.http_status,
+                    "backend_code": source_error.backend_code,
+                    "category": source_error.category,
+                },
+            },
+        }
+
+    def _safe_task_list_items(self, *, profile: str, task_box: str, app_key: str) -> list[dict[str, Any]]:
+        try:
+            response = self.task_list(
+                profile=profile,
+                task_box=task_box,
+                flow_status="all",
+                app_key=app_key,
+                workflow_node_id=None,
+                query=None,
+                page=1,
+                page_size=50,
+            )
+        except QingflowApiError:
+            return []
+        data = response.get("data") if isinstance(response, dict) else None
+        items = data.get("items") if isinstance(data, dict) else None
+        if not isinstance(items, list):
+            return []
+        return [item for item in items if isinstance(item, dict)]
+
+    def task_associated_report_detail_get(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int,
+        workflow_node_id: int,
+        report_id: int,
+        page: int,
+        page_size: int,
+    ) -> dict[str, Any]:
+        self._require_app_record_and_node(app_key, record_id, workflow_node_id)
+        if report_id <= 0:
+            raise_tool_error(QingflowApiError.config_error("report_id must be positive"))
+        if page <= 0 or page_size <= 0:
+            raise_tool_error(QingflowApiError.config_error("page and page_size must be positive"))
+
+        def runner(session_profile, context):
+            task_context = self._build_task_context(
+                profile=profile,
+                context=context,
+                app_key=app_key,
+                record_id=record_id,
+                workflow_node_id=workflow_node_id,
+                include_candidates=False,
+                include_associated_reports=True,
+                current_uid=session_profile.uid,
+            )
+            report_item = self._find_associated_report(task_context, report_id)
+            if report_item is None:
+                raise_tool_error(
+                    QingflowApiError.config_error(
+                        f"report_id={report_id} is not visible for app_key='{app_key}' record_id={record_id} workflow_node_id={workflow_node_id}"
+                    )
+                )
+            association_query = self._build_association_query(
+                report_item["raw"],
+                task_context.get("record", {}).get("answers") or [],
+            )
+            selection = {
+                "app_key": app_key,
+                "record_id": record_id,
+                "workflow_node_id": workflow_node_id,
+                "report_id": report_id,
+                "target_app_key": report_item.get("target_app_key"),
+                "target_app_name": report_item.get("target_app_name"),
+                "chart_key": report_item.get("chart_key"),
+                "chart_name": report_item.get("chart_name"),
+            }
+            context_payload = {
+                "match_rules": report_item.get("match_rules") or [],
+                "resolved_filters": association_query.get("keyQueValues") or [],
+            }
+
+            if report_item.get("graph_type") == "view":
+                viewgraph_key = str(report_item.get("chart_key") or "")
+                body = {
+                    "filter": {},
+                    "viewgraphKey": viewgraph_key,
+                    "equipmentType": 0,
+                    "associationQuery": association_query,
+                }
+                result = self.backend.request(
+                    "POST",
+                    context,
+                    f"/view/{viewgraph_key}/apply/filter",
+                    json_body=body,
+                )
+                items = _task_page_items(result)
+                return {
+                    "profile": profile,
+                    "ws_id": session_profile.selected_ws_id,
+                    "ok": True,
+                    "request_route": self._request_route_payload(context),
+                    "warnings": [],
+                    "output_profile": "normal",
+                    "data": {
+                        "result_type": "view_list",
+                        "result": {
+                            "items": items,
+                            "pagination": {
+                                "page": page,
+                                "page_size": page_size,
+                                "returned_items": len(items),
+                                "page_amount": _task_page_amount(result),
+                                "reported_total": _task_page_total(result),
+                            },
+                        },
+                        "selection": selection,
+                        "context": context_payload,
+                    },
+                }
+
+            chart_key = str(report_item.get("chart_key") or "")
+            source_type = report_item.get("source_type")
+            if source_type == "qingbi":
+                qingbi_context = BackendRequestContext(
+                    base_url=_qingbi_base_url(context.base_url),
+                    token=context.token,
+                    ws_id=context.ws_id,
+                    qf_request_id=context.qf_request_id,
+                    qf_version=context.qf_version,
+                    qf_version_source=context.qf_version_source,
+                )
+                chart_result = self.backend.request(
+                    "POST",
+                    qingbi_context,
+                    f"/qingbi/charts/data/{chart_key}",
+                    params={
+                        "qfUUID": uuid4().hex,
+                        "pageNum": page,
+                        "pageSize": page_size,
+                    },
+                    json_body={
+                        "asosChartId": report_id,
+                        "keyQueValues": association_query.get("keyQueValues") or [],
+                    },
+                )
+                request_route = {
+                    "base_url": qingbi_context.base_url,
+                    "qf_version": qingbi_context.qf_version,
+                    "qf_version_source": qingbi_context.qf_version_source or "context",
+                }
+            elif self._qingflow_chart_uses_apply_filter(context, chart_key):
+                chart_result = self.backend.request(
+                    "POST",
+                    context,
+                    f"/chart/{chart_key}/apply/filter",
+                    json_body={
+                        "filter": {
+                            "pageNum": page,
+                            "pageSize": page_size,
+                        },
+                        "asosChartId": report_id,
+                        "keyQueValues": association_query.get("keyQueValues") or [],
+                    },
+                )
+                items = _task_page_items(chart_result)
+                return {
+                    "profile": profile,
+                    "ws_id": session_profile.selected_ws_id,
+                    "ok": True,
+                    "request_route": self._request_route_payload(context),
+                    "warnings": [],
+                    "output_profile": "normal",
+                    "data": {
+                        "result_type": "view_list",
+                        "result": {
+                            "items": items,
+                            "pagination": {
+                                "page": page,
+                                "page_size": page_size,
+                                "returned_items": len(items),
+                                "page_amount": _task_page_amount(chart_result),
+                                "reported_total": _task_page_total(chart_result),
+                            },
+                        },
+                        "selection": selection,
+                        "context": context_payload,
+                    },
+                }
+            else:
+                chart_result = self.backend.request(
+                    "POST",
+                    context,
+                    f"/chart/{chart_key}/chartData",
+                    json_body={
+                        "asosChartId": report_id,
+                        "keyQueValues": association_query.get("keyQueValues") or [],
+                    },
+                )
+                request_route = self._request_route_payload(context)
+
+            return {
+                "profile": profile,
+                "ws_id": session_profile.selected_ws_id,
+                "ok": True,
+                "request_route": request_route,
+                "warnings": [],
+                "output_profile": "normal",
+                "data": {
+                    "result_type": "chart_data",
+                    "result": self._normalize_chart_result(chart_result),
+                    "selection": selection,
+                    "context": context_payload,
+                },
+            }
+
+        return self._run(profile, runner)
+
+    def task_workflow_log_get(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int,
+        workflow_node_id: int,
+    ) -> dict[str, Any]:
+        self._require_app_record_and_node(app_key, record_id, workflow_node_id)
+
+        def runner(session_profile, context):
+            task_context = self._build_task_context(
+                profile=profile,
+                context=context,
+                app_key=app_key,
+                record_id=record_id,
+                workflow_node_id=workflow_node_id,
+                include_candidates=False,
+                include_associated_reports=False,
+                current_uid=session_profile.uid,
+            )
+            visibility = task_context.get("visibility") or {}
+            if not visibility.get("audit_record_visible"):
+                raise_tool_error(
+                    QingflowApiError.config_error(
+                        f"workflow logs are not visible for app_key='{app_key}' record_id={record_id} workflow_node_id={workflow_node_id}"
+                    )
+                )
+            page = self.backend.request(
+                "POST",
+                context,
+                "/application/workflow/node/record",
+                json_body={
+                    "key": app_key,
+                    "rowRecordId": record_id,
+                    "nodeId": workflow_node_id,
+                    "role": 3,
+                    "pageNum": 1,
+                    "pageSize": 200,
+                },
+            )
+            items = self._normalize_workflow_logs(page)
+            return {
+                "profile": profile,
+                "ws_id": session_profile.selected_ws_id,
+                "ok": True,
+                "request_route": self._request_route_payload(context),
+                "warnings": [],
+                "output_profile": "normal",
+                "data": {
+                    "selection": {
+                        "app_key": app_key,
+                        "record_id": record_id,
+                        "workflow_node_id": workflow_node_id,
+                    },
+                    "visibility": {
+                        "audit_record_visible": visibility.get("audit_record_visible"),
+                        "qrobot_record_visible": visibility.get("qrobot_record_visible"),
+                    },
+                    "items": items,
+                },
+            }
+
+        return self._run(profile, runner)
+
+    def _build_task_context(
+        self,
+        profile: str,
+        context: BackendRequestContext,
+        *,
+        app_key: str,
+        record_id: int,
+        workflow_node_id: int,
+        include_candidates: bool,
+        include_associated_reports: bool,
+        current_uid: int | None = None,
+    ) -> dict[str, Any]:
+        audit_infos = self.backend.request(
+            "GET",
+            context,
+            f"/app/{app_key}/apply/{record_id}/auditInfo",
+            params={"type": 1},
+        )
+        node_info = self._select_task_node(audit_infos, workflow_node_id, app_key=app_key, record_id=record_id)
+        detail = self.backend.request(
+            "GET",
+            context,
+            f"/app/{app_key}/apply/{record_id}",
+            params={"role": 3, "listType": 1, "auditNodeId": workflow_node_id},
+        )
+        associated_report_visible = self._resolve_associated_report_visible(node_info, detail)
+        associated_reports = {"visible": associated_report_visible, "count": 0, "items": []}
+        if include_associated_reports and associated_report_visible:
+            asos_chart_list = self.backend.request(
+                "GET",
+                context,
+                f"/app/{app_key}/asosChart",
+                params={"role": 3, "auditNodeId": workflow_node_id, "beingDraft": False},
+            )
+            associated_items = [
+                self._normalize_associated_report(item)
+                for item in (asos_chart_list.get("asosCharts") or [])
+                if isinstance(item, dict)
+            ]
+            associated_reports = {
+                "visible": True,
+                "count": len(associated_items),
+                "items": associated_items,
+            }
+        rollback_items: list[dict[str, Any]] = []
+        transfer_items: list[dict[str, Any]] = []
+        if include_candidates:
+            rollback_result = self.backend.request(
+                "GET",
+                context,
+                f"/app/{app_key}/apply/{record_id}/revertNode",
+                params={"auditNodeId": workflow_node_id},
+            )
+            rollback_items = self._rollback_candidate_items(rollback_result)
+            transfer_result = self.backend.request(
+                "GET",
+                context,
+                f"/app/{app_key}/apply/{record_id}/transfer/member",
+                params={"pageNum": 1, "pageSize": 20, "auditNodeId": workflow_node_id},
+            )
+            transfer_items = self._filter_transfer_members(_approval_page_items(transfer_result), current_uid=current_uid)
+
+        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": {
+                "app_key": app_key,
+                "record_id": record_id,
+                "workflow_node_id": workflow_node_id,
+                "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"),
+                "apply_num": detail.get("applyNum"),
+                "custom_apply_num": detail.get("customApplyNum"),
+                "apply_user": detail.get("applyUser"),
+                "apply_time": detail.get("applyTime"),
+                "last_update_time": detail.get("lastUpdateTime"),
+                "answers": detail.get("answers") or [],
+            },
+            "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,
+            "candidates": {
+                "rollback_nodes": rollback_items,
+                "transfer_members": transfer_items,
+            },
+            "workflow_log_summary": {
+                "visible": visibility["audit_record_visible"],
+                "available": visibility["audit_record_visible"],
+                "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]:
+        app_key = raw.get("appKey") or raw.get("app_key")
+        record_id = raw.get("rowRecordId") or raw.get("recordId") or raw.get("applyId")
+        workflow_node_id = raw.get("nodeId") or raw.get("auditNodeId")
+        apply_user = raw.get("applyUser")
+        if apply_user is None:
+            user_uid = raw.get("applyUserUid")
+            user_name = raw.get("applyUserName")
+            if user_uid is not None or user_name is not None:
+                apply_user = {"uid": user_uid, "name": user_name}
+        return {
+            "task_id": raw.get("id") or raw.get("taskId") or record_id,
+            "app_key": app_key,
+            "app_name": raw.get("formTitle") or raw.get("worksheetName") or raw.get("appName"),
+            "record_id": record_id,
+            "workflow_node_id": workflow_node_id,
+            "workflow_node_name": raw.get("nodeName") or raw.get("auditNodeName"),
+            "title": raw.get("title") or raw.get("applyTitle") or raw.get("name") or raw.get("formTitle"),
+            "apply_user": apply_user,
+            "apply_time": raw.get("applyTime") or raw.get("receiveTime"),
+            "task_box": task_box,
+            "flow_status": flow_status,
+            "actionable": task_box == "todo" and bool(record_id) and bool(workflow_node_id),
+        }
+
+    def _select_task_node(self, infos: Any, workflow_node_id: int, *, app_key: str, record_id: int) -> dict[str, Any]:
+        if not isinstance(infos, list) or not infos:
+            raise_tool_error(
+                QingflowApiError.config_error(
+                    f"record_id={record_id} is not currently actionable for the logged-in user in app_key='{app_key}'"
+                )
+            )
+        for item in infos:
+            if not isinstance(item, dict):
+                continue
+            candidate = item.get("auditNodeId")
+            if not isinstance(candidate, int):
+                candidate = item.get("nodeId")
+            if candidate == workflow_node_id:
+                return item
+        raise_tool_error(
+            QingflowApiError.config_error(
+                f"workflow_node_id={workflow_node_id} is not an actionable todo node for app_key='{app_key}' record_id={record_id}"
+            )
+        )
+
+    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")
+        if self._coerce_bool(node_info.get("canRevert")):
+            available_actions.append("rollback")
+        if self._coerce_bool(node_info.get("canTransfer")):
+            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")):
+            visible_but_unimplemented_actions.append("revoke")
+        if self._coerce_bool(node_info.get("beingEndWorkflow")):
+            visible_but_unimplemented_actions.append("end_workflow")
+        if self._coerce_bool(node_info.get("beingCanApplyAgain")):
+            visible_but_unimplemented_actions.append("apply_again")
+
+        feedback_required_for = []
+        raw_feedback_required = node_info.get("feedbackRequiredOperationType")
+        if isinstance(raw_feedback_required, list):
+            feedback_required_for = [str(item).strip().lower() for item in raw_feedback_required if str(item).strip()]
+
+        return {
+            "available_actions": available_actions,
+            "visible_but_unimplemented_actions": visible_but_unimplemented_actions,
+            "action_constraints": {
+                "feedback_required_for": feedback_required_for,
+                "submit_check_enabled": self._coerce_bool(node_info.get("beingSubmitCheck")),
+                "submit_preview_enabled": self._coerce_bool(node_info.get("beingSubmitPreview")),
+                "can_end_workflow": self._coerce_bool(node_info.get("beingEndWorkflow")),
+                "can_apply_again": self._coerce_bool(node_info.get("beingCanApplyAgain")),
+            },
+        }
+
+    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")),
+            "audit_record_visible": self._coerce_bool(node_info.get("auditRecordVisible")),
+            "workflow_future_visible": self._coerce_bool(node_info.get("beingWorkflowNodeFutureListVisible")),
+            "qrobot_record_visible": self._coerce_bool(node_info.get("qrobotRecordBeingVisible")),
+            "associated_report_visible": self._resolve_associated_report_visible(node_info, detail),
+        }
+
+    def _resolve_associated_report_visible(self, node_info: dict[str, Any], detail: dict[str, Any]) -> bool:
+        node_visible = node_info.get("asosChartVisible")
+        if node_visible is not None:
+            return self._coerce_bool(node_visible)
+        return self._coerce_bool(detail.get("viewAsosChartVisible"))
+
+    def _normalize_associated_report(self, raw: dict[str, Any]) -> dict[str, Any]:
+        graph_type = str(raw.get("graphType") or "").strip().lower()
+        source_type = str(raw.get("sourceType") or "").strip().lower()
+        return {
+            "report_id": raw.get("id"),
+            "chart_key": raw.get("chartKey"),
+            "chart_name": raw.get("chartName"),
+            "graph_type": "view" if graph_type.endswith("view") or graph_type == "view" else "chart",
+            "source_type": source_type or "qingflow",
+            "target_app_key": raw.get("appKey"),
+            "target_app_name": raw.get("formTitle"),
+            "match_rules": raw.get("matchRules") or [],
+            "raw": dict(raw),
+        }
+
+    def _rollback_candidate_items(self, payload: Any) -> list[dict[str, Any]]:
+        if isinstance(payload, dict):
+            revert_nodes = payload.get("revertNodes")
+            if isinstance(revert_nodes, list):
+                return [item for item in revert_nodes if isinstance(item, dict)]
+        return [item for item in _approval_page_items(payload) if isinstance(item, dict)]
+
+    def _filter_transfer_members(self, items: Any, *, current_uid: int | None) -> list[dict[str, Any]]:
+        if not isinstance(items, list):
+            return []
+        filtered: list[dict[str, Any]] = []
+        for item in items:
+            if not isinstance(item, dict):
+                continue
+            if current_uid is not None and item.get("uid") == current_uid:
+                continue
+            filtered.append(item)
+        return filtered
+
+    def _find_associated_report(self, task_context: dict[str, Any], report_id: int) -> dict[str, Any] | None:
+        associated_reports = ((task_context.get("associated_reports") or {}).get("items") or [])
+        for item in associated_reports:
+            if isinstance(item, dict) and item.get("report_id") == report_id:
+                return item
+        return None
+
+    def _build_association_query(self, asos_chart: dict[str, Any], answers: list[dict[str, Any]]) -> dict[str, Any]:
+        key_que_ids = self._collect_match_rule_question_ids(asos_chart.get("matchRules") or [])
+        key_values: list[dict[str, Any]] = []
+        for answer in answers:
+            if not isinstance(answer, dict):
+                continue
+            answer_que_id = answer.get("queId")
+            if isinstance(answer_que_id, int) and answer_que_id in key_que_ids:
+                extracted_values = self._extract_answer_values(answer)
+                key_values.append({"keyQueId": answer_que_id, "values": extracted_values or None})
+            table_values = answer.get("tableValues")
+            if not isinstance(table_values, list):
+                continue
+            for idx, row in enumerate(table_values, start=1):
+                if not isinstance(row, list):
+                    continue
+                for sub_answer in row:
+                    if not isinstance(sub_answer, dict):
+                        continue
+                    sub_que_id = sub_answer.get("queId")
+                    if isinstance(sub_que_id, int) and sub_que_id in key_que_ids:
+                        extracted_values = self._extract_answer_values(sub_answer)
+                        key_values.append(
+                            {
+                                "keyQueId": sub_que_id,
+                                "ordinal": idx,
+                                "values": extracted_values or None,
+                            }
+                        )
+        return {
+            "asosChart": self._sanitize_associated_chart(asos_chart),
+            "keyQueValues": key_values,
+        }
+
+    def _collect_match_rule_question_ids(self, match_rules: Any) -> set[int]:
+        question_ids: set[int] = set()
+
+        def visit(node: Any) -> None:
+            if isinstance(node, list):
+                for item in node:
+                    visit(item)
+                return
+            if not isinstance(node, dict):
+                return
+            for key in ("queId", "judgeQueId"):
+                value = node.get(key)
+                if isinstance(value, int):
+                    question_ids.add(value)
+            for value in node.values():
+                if isinstance(value, (list, dict)):
+                    visit(value)
+
+        visit(match_rules)
+        return question_ids
+
+    def _extract_answer_values(self, answer: dict[str, Any]) -> list[str]:
+        values = answer.get("values")
+        if not isinstance(values, list):
+            return []
+        normalized: list[str] = []
+        for item in values:
+            if item is None:
+                continue
+            if isinstance(item, (str, int, float, bool)):
+                normalized.append(str(item))
+                continue
+            if not isinstance(item, dict):
+                continue
+            for key in ("value", "id", "uid", "userId", "applyId", "phone", "email", "name", "title", "label"):
+                value = item.get(key)
+                if value not in (None, ""):
+                    normalized.append(str(value))
+                    break
+        deduped: list[str] = []
+        seen: set[str] = set()
+        for item in normalized:
+            if item in seen:
+                continue
+            deduped.append(item)
+            seen.add(item)
+        return deduped
+
+    def _sanitize_associated_chart(self, asos_chart: dict[str, Any]) -> dict[str, Any]:
+        return {
+            "id": asos_chart.get("id"),
+            "appKey": asos_chart.get("appKey"),
+            "formTitle": asos_chart.get("formTitle"),
+            "chartKey": asos_chart.get("chartKey"),
+            "chartName": asos_chart.get("chartName"),
+            "chartType": asos_chart.get("chartType"),
+            "matchRules": asos_chart.get("matchRules") or [],
+            "sourceType": asos_chart.get("sourceType"),
+            "graphType": asos_chart.get("graphType"),
+            "viewType": asos_chart.get("viewType"),
+        }
+
+    def _qingflow_chart_uses_apply_filter(self, context: BackendRequestContext, chart_key: str) -> bool:
+        if not chart_key:
+            return False
+        try:
+            auth = self.backend.request(
+                "GET",
+                context,
+                f"/chart/{chart_key}/auth",
+            )
+        except QingflowApiError:
+            return False
+        if not isinstance(auth, dict):
+            return False
+        return self._coerce_bool(auth.get("detailedViewStatus")) and auth.get("lastViewType") == 1
+
+    def _normalize_chart_result(self, payload: Any) -> dict[str, Any]:
+        if isinstance(payload, dict):
+            rows = payload.get("rows")
+            if not isinstance(rows, list):
+                rows = payload.get("list") if isinstance(payload.get("list"), list) else []
+            series = payload.get("series")
+            if not isinstance(series, list):
+                series = payload.get("xAxis") if isinstance(payload.get("xAxis"), list) else []
+            metrics = payload.get("metrics")
+            if not isinstance(metrics, list):
+                metrics = payload.get("yAxis") if isinstance(payload.get("yAxis"), list) else []
+            summary = payload.get("summary") if isinstance(payload.get("summary"), dict) else {}
+            return {
+                "summary": summary,
+                "rows": rows or [],
+                "series": series or [],
+                "metrics": metrics or [],
+            }
+        if isinstance(payload, list):
+            return {"summary": {}, "rows": payload, "series": [], "metrics": []}
+        return {"summary": {}, "rows": [], "series": [], "metrics": []}
+
+    def _normalize_workflow_logs(self, payload: Any) -> list[dict[str, Any]]:
+        if isinstance(payload, dict):
+            page = payload.get("list") if isinstance(payload.get("list"), list) else payload.get("rows")
+            if not isinstance(page, list):
+                nested = payload.get("data")
+                if isinstance(nested, dict):
+                    page = nested.get("list") if isinstance(nested.get("list"), list) else nested.get("rows")
+            if not isinstance(page, list):
+                page = []
+        elif isinstance(payload, list):
+            page = payload
+        else:
+            page = []
+
+        items: list[dict[str, Any]] = []
+        for node_record in page:
+            if not isinstance(node_record, dict):
+                continue
+            node_id = node_record.get("nodeId")
+            node_name = node_record.get("nodeName")
+            operation_record_list = node_record.get("operationRecordList")
+            if not isinstance(operation_record_list, list):
+                operation_record_list = []
+            for operation in operation_record_list:
+                if not isinstance(operation, dict):
+                    continue
+                detail = self._first_nested_operation_detail(operation)
+                items.append(
+                    {
+                        "log_id": operation.get("workflowNodeOperationRecordId")
+                        or node_record.get("workflowNodeProcessRecordId"),
+                        "node_id": node_id,
+                        "node_name": node_name,
+                        "operator": operation.get("operator"),
+                        "operation": operation.get("operationType"),
+                        "operation_result": detail,
+                        "operation_time": operation.get("operationTime"),
+                        "remark": self._extract_remark(detail),
+                        "signature_url": self._extract_signature_url(detail),
+                        "attachments": self._extract_attachments(detail),
+                        "qrobot_related": any(
+                            operation.get(key)
+                            for key in ("qRobotAdd", "qRobotUpdate", "qRobotSMS", "qRobotMail", "webhook")
+                        ),
+                    }
+                )
+        return items
+
+    def _workflow_log_digest(self, items: list[dict[str, Any]]) -> str | None:
+        if not items:
+            return None
+        try:
+            return json.dumps(items, ensure_ascii=False, sort_keys=True, default=str)
+        except TypeError:
+            return str(items)
+
+    def _first_nested_operation_detail(self, operation: dict[str, Any]) -> Any:
+        for key in ("approval", "filling", "cc", "applicant", "qRobotAdd", "qRobotUpdate", "webhook", "qRobotSMS", "qRobotMail"):
+            value = operation.get(key)
+            if value is not None:
+                return value
+        return None
+
+    def _extract_remark(self, detail: Any) -> Any:
+        if not isinstance(detail, dict):
+            return None
+        for key in ("remark", "feedback", "comment", "content"):
+            value = detail.get(key)
+            if value not in (None, ""):
+                return value
+        return None
+
+    def _extract_signature_url(self, detail: Any) -> Any:
+        if not isinstance(detail, dict):
+            return None
+        for key in ("signatureUrl", "handSignImageUrl"):
+            value = detail.get(key)
+            if value not in (None, ""):
+                return value
+        return None
+
+    def _extract_attachments(self, detail: Any) -> Any:
+        if not isinstance(detail, dict):
+            return []
+        for key in ("attachments", "files", "uploadFiles"):
+            value = detail.get(key)
+            if isinstance(value, list):
+                return value
+        return []
+
+    def _extract_audit_feedback(self, payload: dict[str, Any]) -> str | None:
+        for key in ("audit_feedback", "auditFeedback"):
+            value = payload.get(key)
+            if isinstance(value, str) and value.strip():
+                return value.strip()
+        return None
+
+    def _extract_positive_int(self, payload: dict[str, Any], key: str, *, aliases: tuple[str, ...] = ()) -> int:
+        candidates = (key, *aliases)
+        value: Any = None
+        for candidate in candidates:
+            if candidate in payload:
+                value = payload.get(candidate)
+                break
+        if not isinstance(value, int) or value <= 0:
+            names = ", ".join(candidates)
+            raise_tool_error(QingflowApiError.config_error(f"one of [{names}] must be a positive integer"))
+        return value
+
+    def _require_app_record_and_node(self, app_key: str, record_id: int, workflow_node_id: int) -> None:
+        if not app_key:
+            raise_tool_error(QingflowApiError.config_error("app_key is required"))
+        if record_id <= 0:
+            raise_tool_error(QingflowApiError.config_error("record_id must be positive"))
+        if workflow_node_id <= 0:
+            raise_tool_error(QingflowApiError.config_error("workflow_node_id must be positive"))
+
+    def _coerce_bool(self, value: Any) -> bool:
+        if isinstance(value, bool):
+            return value
+        if isinstance(value, int):
+            return value != 0
+        if isinstance(value, str):
+            return value.strip().lower() in {"1", "true", "yes", "y", "show", "visible", "enabled"}
+        return bool(value)
+
+    def _request_route_payload(self, context: BackendRequestContext) -> dict[str, Any]:
+        describe_route = getattr(self.backend, "describe_route", None)
+        if callable(describe_route):
+            payload = describe_route(context)
+            if isinstance(payload, dict):
+                return payload
+        return {
+            "base_url": context.base_url,
+            "qf_version": context.qf_version,
+            "qf_version_source": context.qf_version_source or ("context" if context.qf_version else "unknown"),
+        }