@qingflow-tech/qingflow-app-user-mcp 1.0.11 → 1.0.13

package/src/qingflow_mcp/tools/task_context_tools.py

@@ -9,12 +9,12 @@ from mcp.server.fastmcp import FastMCP
 
 from ..backend_client import BackendRequestContext
 from ..config import DEFAULT_PROFILE
-from ..errors import QingflowApiError, raise_tool_error
+from ..errors import QingflowApiError, backend_code_int, backend_code_value_int, is_auth_like_error, message_looks_like_invalid_token, raise_tool_error
 from ..id_utils import ids_equal, normalize_positive_id_int, normalize_positive_id_text, stringify_backend_id
 from ..json_types import JSONObject
 from .approval_tools import ApprovalTools, _approval_page_amount, _approval_page_items, _approval_page_total
 from .base import ToolBase, tool_cn_name
-from .qingbi_report_tools import _qingbi_base_url
+from .qingbi_report_tools import _qingbi_base_url, _should_retry_asos_data
 from .record_tools import (
     FieldIndex,
     LAYOUT_ONLY_QUE_TYPES,
@@ -271,6 +271,7 @@ class TaskContextTools(ToolBase):
             resolved_app_key = str(locator["app_key"])
             resolved_record_id = int(locator["record_id"])
             resolved_workflow_node_id = int(locator["workflow_node_id"])
+            resolved_task_box = str(locator.get("task_box") or "todo")
             self._require_app_record_and_node(resolved_app_key, resolved_record_id, resolved_workflow_node_id)
             data = self._build_task_context(
                 profile=profile,
@@ -278,10 +279,12 @@ class TaskContextTools(ToolBase):
                 app_key=resolved_app_key,
                 record_id=resolved_record_id,
                 workflow_node_id=resolved_workflow_node_id,
+                task_box=resolved_task_box,
                 include_candidates=include_candidates,
                 include_associated_reports=include_associated_reports,
                 current_uid=session_profile.uid,
             )
+            context_warnings = data.get("warnings") if isinstance(data.get("warnings"), list) else []
             data = self._compact_task_get_context(data)
             task_payload = data.get("task")
             if isinstance(task_payload, dict) and task_id_text is not None:
@@ -291,7 +294,7 @@ class TaskContextTools(ToolBase):
                 "ws_id": session_profile.selected_ws_id,
                 "ok": True,
                 "request_route": self._request_route_payload(context),
-                "warnings": [],
+                "warnings": context_warnings,
                 "output_profile": "normal",
                 "data": data,
             }
@@ -368,8 +371,63 @@ class TaskContextTools(ToolBase):
             resolved_record_id = int(locator["record_id"])
             resolved_record_id_text = str(locator["record_id_text"] or "")
             resolved_workflow_node_id = int(locator["workflow_node_id"])
+            resolved_task_box = str(locator.get("task_box") or "todo")
             record_id_text = resolved_record_id_text
             self._require_app_record_and_node(resolved_app_key, resolved_record_id, resolved_workflow_node_id)
+            if normalized_action == "urge":
+                raw = self._execute_task_action(
+                    profile=profile,
+                    app_key=resolved_app_key,
+                    record_id=resolved_record_id,
+                    workflow_node_id=resolved_workflow_node_id,
+                    normalized_action=normalized_action,
+                    payload=body,
+                    prepared_fields=None,
+                )
+                verification, verification_warnings = self._verify_task_action_runtime(
+                    profile=profile,
+                    context=context,
+                    app_key=resolved_app_key,
+                    record_id=resolved_record_id,
+                    workflow_node_id=resolved_workflow_node_id,
+                    action=normalized_action,
+                    before_apply_status=None,
+                    runtime_baseline=None,
+                )
+                result = {
+                    "profile": raw.get("profile", profile),
+                    "ws_id": raw.get("ws_id", session_profile.selected_ws_id),
+                    "ok": bool(raw.get("ok", True)),
+                    "status": "success",
+                    "error_code": None,
+                    "action_executed": True,
+                    "safe_to_retry": False,
+                    "request_route": raw.get("request_route") or self._request_route_payload(context),
+                    "warnings": verification_warnings,
+                    "verification": verification,
+                    "output_profile": "normal",
+                    "data": {
+                        "action": normalized_action,
+                        "resource": {
+                            "app_key": resolved_app_key,
+                            "record_id": record_id_text,
+                            "workflow_node_id": resolved_workflow_node_id,
+                        },
+                        "selection": {"action": normalized_action},
+                        "result": raw.get("result"),
+                        "human_review": True,
+                        "field_update_applied": False,
+                    },
+                }
+                if task_id_text is not None:
+                    result["data"]["resource"]["task_id"] = task_id_text
+                return result
+            if resolved_task_box != "todo":
+                raise_tool_error(
+                    QingflowApiError.config_error(
+                        f"task_id={task_id_text or ''} resolved to task_box='{resolved_task_box}', but task_action_execute can only execute current todo tasks"
+                    )
+                )
             try:
                 task_context = self._build_task_context(
                     profile=profile,
@@ -377,12 +435,13 @@ class TaskContextTools(ToolBase):
                     app_key=resolved_app_key,
                     record_id=resolved_record_id,
                     workflow_node_id=resolved_workflow_node_id,
+                    task_box=resolved_task_box,
                     include_candidates=False,
                     include_associated_reports=False,
                     current_uid=session_profile.uid,
                 )
             except QingflowApiError as error:
-                if error.backend_code == 46001:
+                if backend_code_int(error) == 46001:
                     return self._task_action_visibility_unverified_response(
                         profile=profile,
                         session_profile=session_profile,
@@ -470,7 +529,7 @@ class TaskContextTools(ToolBase):
                     prepared_fields=prepared_fields,
                 )
             except QingflowApiError as error:
-                if error.backend_code == 46001:
+                if backend_code_int(error) == 46001:
                     return self._task_action_visibility_unverified_response(
                         profile=profile,
                         session_profile=session_profile,
@@ -518,6 +577,8 @@ class TaskContextTools(ToolBase):
                 "ok": bool(raw.get("ok", True)) and status != "failed",
                 "status": status,
                 "error_code": error_code,
+                "action_executed": True,
+                "safe_to_retry": False,
                 "request_route": raw.get("request_route") or self._request_route_payload(context),
                 "warnings": warnings,
                 "verification": verification,
@@ -680,6 +741,8 @@ class TaskContextTools(ToolBase):
                 "http_status": error.http_status,
                 "backend_code": error.backend_code,
                 "category": error.category,
+                "request_id": error.request_id,
+                "message": error.message,
             }
 
         log_items: list[dict[str, Any]] = []
@@ -707,6 +770,8 @@ class TaskContextTools(ToolBase):
                 "http_status": error.http_status,
                 "backend_code": error.backend_code,
                 "category": error.category,
+                "request_id": error.request_id,
+                "message": error.message,
             }
 
         todo_items = self._safe_task_list_items(profile=profile, task_box="todo", app_key=app_key)
@@ -756,7 +821,7 @@ class TaskContextTools(ToolBase):
         runtime_consumed_after_action = bool(
             runtime_verified
             and isinstance(record_state_error, dict)
-            and record_state_error.get("backend_code") == 46001
+            and backend_code_value_int(record_state_error.get("backend_code")) == 46001
         )
         if runtime_consumed_after_action:
             verification["record_state_scope"] = "current_node_runtime"
@@ -771,6 +836,28 @@ class TaskContextTools(ToolBase):
                     ),
                 }
             )
+        permission_blocked_sources: list[str] = []
+        if (
+            isinstance(verification.get("record_state_error"), dict)
+            and _is_permission_context_error_payload(verification["record_state_error"])
+        ):
+            permission_blocked_sources.append("record_state")
+        if (
+            isinstance(verification.get("workflow_log_error"), dict)
+            and _is_permission_context_error_payload(verification["workflow_log_error"])
+        ):
+            permission_blocked_sources.append("workflow_log")
+        if permission_blocked_sources:
+            warnings.append(
+                {
+                    "code": "TASK_ACTION_VERIFICATION_PERMISSION_UNAVAILABLE",
+                    "message": (
+                        "task action executed, but some post-action verification reads are unavailable "
+                        "in this permission context; do not treat the verification read failure as action denial."
+                    ),
+                    "sources": permission_blocked_sources,
+                }
+            )
         verification["runtime_continuation_verified"] = runtime_verified
         if not runtime_verified:
             warnings.append(
@@ -931,7 +1018,9 @@ class TaskContextTools(ToolBase):
             baseline["workflow_log_visible"] = True
             baseline["workflow_log_count"] = len(log_items)
             baseline["workflow_log_digest"] = self._workflow_log_digest(log_items)
-        except QingflowApiError:
+        except QingflowApiError as exc:
+            if is_auth_like_error(exc):
+                raise
             pass
         todo_items = self._safe_task_list_items(profile=profile, task_box="todo", app_key=app_key)
         baseline["downstream_todo_nodes"] = sorted(
@@ -1058,7 +1147,9 @@ class TaskContextTools(ToolBase):
                 page=1,
                 page_size=50,
             )
-        except QingflowApiError:
+        except QingflowApiError as exc:
+            if not _is_task_optional_read_error(exc):
+                raise
             return []
         items = response.get("items") if isinstance(response, dict) else None
         if not isinstance(items, list):
@@ -1152,21 +1243,35 @@ class TaskContextTools(ToolBase):
         task_id_text = normalize_positive_id_text(task_id, field_name="task_id")
         searched_task_boxes = ("todo", "initiated", "cc", "done")
         incomplete_task_boxes: list[str] = []
+        inaccessible_task_boxes: list[dict[str, Any]] = []
         page_size = 100
         for task_box in searched_task_boxes:
             page = 1
             page_amount: int | None = None
             while True:
-                response = self._list_normalized_task_items(
-                    profile=profile,
-                    task_box=task_box,
-                    flow_status="all",
-                    app_key=None,
-                    workflow_node_id=None,
-                    query=None,
-                    page=page,
-                    page_size=page_size,
-                )
+                try:
+                    response = self._list_normalized_task_items(
+                        profile=profile,
+                        task_box=task_box,
+                        flow_status="all",
+                        app_key=None,
+                        workflow_node_id=None,
+                        query=None,
+                        page=page,
+                        page_size=page_size,
+                    )
+                except QingflowApiError as exc:
+                    if not _is_optional_task_box_locator_error(exc):
+                        raise
+                    inaccessible_task_boxes.append(
+                        {
+                            "task_box": task_box,
+                            "backend_code": exc.backend_code,
+                            "http_status": exc.http_status,
+                            "request_id": exc.request_id,
+                        }
+                    )
+                    break
                 items = response.get("items") if isinstance(response.get("items"), list) else []
                 for item in items:
                     if not isinstance(item, dict) or not ids_equal(item.get("task_id"), task_id_text):
@@ -1200,6 +1305,18 @@ class TaskContextTools(ToolBase):
                     f"task_id={task_id_text} resolved to an incomplete task locator in task_box={searched}; please refresh the task list and retry"
                 )
             )
+        if inaccessible_task_boxes:
+            searched = ", ".join(str(item.get("task_box")) for item in inaccessible_task_boxes)
+            raise_tool_error(
+                QingflowApiError.config_error(
+                    f"task_id={task_id_text} was not found in visible task boxes; some task boxes were not searchable in the current permission context: {searched}",
+                    details={
+                        "task_id": task_id_text,
+                        "searched_task_boxes": list(searched_task_boxes),
+                        "inaccessible_task_boxes": inaccessible_task_boxes,
+                    },
+                )
+            )
         raise_tool_error(
             QingflowApiError.config_error(
                 f"task_id={task_id_text} was not found in the current visible task boxes (todo, initiated, cc, done)"
@@ -1224,6 +1341,7 @@ class TaskContextTools(ToolBase):
             resolved_app_key = str(locator["app_key"])
             resolved_record_id = normalize_positive_id_int(locator["record_id"], field_name="record_id")
             resolved_workflow_node_id = int(locator["workflow_node_id"])
+            resolved_task_box = str(locator.get("task_box") or "todo")
             explicit_app_key = (app_key or "").strip()
             if explicit_app_key and explicit_app_key != resolved_app_key:
                 raise_tool_error(
@@ -1248,8 +1366,10 @@ class TaskContextTools(ToolBase):
         else:
             resolved_record_id = normalize_positive_id_int(record_id, field_name="record_id")
             resolved_workflow_node_id = int(workflow_node_id)
+            resolved_task_box = "todo"
         return {
             "task_id": task_id_text,
+            "task_box": resolved_task_box,
             "app_key": resolved_app_key,
             "record_id": resolved_record_id,
             "record_id_text": stringify_backend_id(resolved_record_id),
@@ -1307,6 +1427,7 @@ class TaskContextTools(ToolBase):
             resolved_record_id = int(locator["record_id"])
             record_id_text = str(locator["record_id_text"] or "")
             resolved_workflow_node_id = int(locator["workflow_node_id"])
+            resolved_task_box = str(locator.get("task_box") or "todo")
             self._require_app_record_and_node(resolved_app_key, resolved_record_id, resolved_workflow_node_id)
             task_context = self._build_task_context(
                 profile=profile,
@@ -1314,6 +1435,7 @@ class TaskContextTools(ToolBase):
                 app_key=resolved_app_key,
                 record_id=resolved_record_id,
                 workflow_node_id=resolved_workflow_node_id,
+                task_box=resolved_task_box,
                 include_candidates=False,
                 include_associated_reports=True,
                 current_uid=session_profile.uid,
@@ -1387,7 +1509,7 @@ class TaskContextTools(ToolBase):
 
             chart_key = str(report_item.get("chart_key") or "")
             source_type = report_item.get("source_type")
-            if source_type == "qingbi":
+            if source_type in {"qingbi", "bi_qingflow", "bi_dataset"}:
                 qingbi_context = BackendRequestContext(
                     base_url=_qingbi_base_url(context.base_url),
                     token=context.token,
@@ -1396,20 +1518,44 @@ class TaskContextTools(ToolBase):
                     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 [],
-                    },
-                )
+                chart_payload = {
+                    "asosChartId": report_id,
+                    "keyQueValues": association_query.get("keyQueValues") or [],
+                }
+                chart_params = {
+                    "qfUUID": uuid4().hex,
+                    "pageNum": page,
+                    "pageSize": page_size,
+                }
+                try:
+                    chart_result = self.backend.request(
+                        "POST",
+                        qingbi_context,
+                        f"/qingbi/charts/data/qflow/{chart_key}/detail",
+                        params=chart_params,
+                        json_body=chart_payload,
+                    )
+                except QingflowApiError as error:
+                    if not _should_retry_asos_data(error):
+                        raise
+                    try:
+                        chart_result = self.backend.request(
+                            "POST",
+                            qingbi_context,
+                            f"/qingbi/charts/data/qflow/{chart_key}/asos",
+                            params=chart_params,
+                            json_body=chart_payload,
+                        )
+                    except QingflowApiError as fallback_error:
+                        if not _should_retry_asos_data(fallback_error):
+                            raise
+                        chart_result = self.backend.request(
+                            "POST",
+                            qingbi_context,
+                            f"/qingbi/charts/data/{chart_key}",
+                            params=chart_params,
+                            json_body=chart_payload,
+                        )
                 request_route = {
                     "base_url": qingbi_context.base_url,
                     "qf_version": qingbi_context.qf_version,
@@ -1509,6 +1655,7 @@ class TaskContextTools(ToolBase):
             resolved_record_id = int(locator["record_id"])
             record_id_text = str(locator["record_id_text"] or "")
             resolved_workflow_node_id = int(locator["workflow_node_id"])
+            resolved_task_box = str(locator.get("task_box") or "todo")
             self._require_app_record_and_node(resolved_app_key, resolved_record_id, resolved_workflow_node_id)
             task_context = self._build_task_context(
                 profile=profile,
@@ -1516,12 +1663,16 @@ class TaskContextTools(ToolBase):
                 app_key=resolved_app_key,
                 record_id=resolved_record_id,
                 workflow_node_id=resolved_workflow_node_id,
+                task_box=resolved_task_box,
                 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"):
+            node = task_context.get("node") if isinstance(task_context.get("node"), dict) else {}
+            raw_node = node.get("raw") if isinstance(node.get("raw"), dict) else {}
+            audit_visibility_explicit = "auditRecordVisible" in raw_node
+            if audit_visibility_explicit and not visibility.get("audit_record_visible"):
                 raise_tool_error(
                     QingflowApiError.config_error(
                         f"workflow logs are not visible for app_key='{resolved_app_key}' record_id={record_id_text} workflow_node_id={resolved_workflow_node_id}"
@@ -1535,7 +1686,7 @@ class TaskContextTools(ToolBase):
                     "key": resolved_app_key,
                     "rowRecordId": resolved_record_id,
                     "nodeId": resolved_workflow_node_id,
-                    "role": 3,
+                    "role": _task_box_record_role(resolved_task_box),
                     "pageNum": 1,
                     "pageSize": 200,
                 },
@@ -1546,7 +1697,7 @@ class TaskContextTools(ToolBase):
                 "ws_id": session_profile.selected_ws_id,
                 "ok": True,
                 "request_route": self._request_route_payload(context),
-                "warnings": [],
+                "warnings": task_context.get("warnings") or [],
                 "output_profile": "normal",
                 "data": {
                     "selection": {
@@ -1555,7 +1706,9 @@ class TaskContextTools(ToolBase):
                         "workflow_node_id": resolved_workflow_node_id,
                     },
                     "visibility": {
-                        "audit_record_visible": visibility.get("audit_record_visible"),
+                        "audit_record_visible": (
+                            visibility.get("audit_record_visible") if audit_visibility_explicit else None
+                        ),
                         "qrobot_record_visible": visibility.get("qrobot_record_visible"),
                     },
                     "items": items,
@@ -1580,43 +1733,94 @@ class TaskContextTools(ToolBase):
         include_candidates: bool,
         include_associated_reports: bool,
         current_uid: int | None = None,
+        task_box: str = "todo",
     ) -> 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},
-        )
-        app_name = self._task_app_name(context=context, app_key=app_key, detail=detail, node_info=node_info)
-        associated_report_visible = self._resolve_associated_report_visible(node_info, detail)
-        associated_reports = {"visible": associated_report_visible, "loaded": False, "count": 0, "items": []}
-        if include_associated_reports and associated_report_visible:
-            asos_chart_list = self.backend.request(
+        context_warnings: list[JSONObject] = []
+        detail: dict[str, Any] | None = None
+        list_type = _task_box_record_list_type(task_box)
+        role = _task_box_record_role(task_box)
+        try:
+            audit_infos = self.backend.request(
                 "GET",
                 context,
-                f"/app/{app_key}/asosChart",
-                params={"role": 3, "auditNodeId": workflow_node_id, "beingDraft": False},
+                f"/app/{app_key}/apply/{record_id}/auditInfo",
+                params={"type": list_type},
             )
-            associated_items = [
-                self._normalize_associated_report(item)
-                for item in (asos_chart_list.get("asosCharts") or [])
-                if isinstance(item, dict)
-            ]
-            associated_reports = {
-                "visible": True,
-                "loaded": True,
-                "count": len(associated_items),
-                "items": associated_items,
-            }
+            node_info = self._select_task_node(audit_infos, workflow_node_id, app_key=app_key, record_id=record_id)
+        except QingflowApiError as exc:
+            if not _is_optional_task_audit_info_error(exc):
+                raise
+            detail = self.backend.request(
+                "GET",
+                context,
+                f"/app/{app_key}/apply/{record_id}",
+                params={"role": role, "listType": list_type, "auditNodeId": workflow_node_id},
+            )
+            node_info = self._fallback_task_node_from_detail(
+                detail,
+                workflow_node_id=workflow_node_id,
+                source_error=exc,
+            )
+            context_warnings.append(
+                {
+                    "code": "TASK_AUDIT_INFO_UNAVAILABLE",
+                    "message": "Task context used the current task detail because auditInfo was unavailable in this permission context.",
+                    "backend_code": exc.backend_code,
+                    "request_id": exc.request_id,
+                    "http_status": exc.http_status,
+                }
+            )
+        if detail is None:
+            detail = self.backend.request(
+                "GET",
+                context,
+                f"/app/{app_key}/apply/{record_id}",
+                params={"role": role, "listType": list_type, "auditNodeId": workflow_node_id},
+            )
+        app_name = self._task_app_name(context=context, app_key=app_key, detail=detail, node_info=node_info)
+        associated_report_visible = self._resolve_associated_report_visible(node_info, detail)
+        associated_reports = {"visible": associated_report_visible, "loaded": False, "count": 0, "items": [], "warnings": []}
+        if include_associated_reports and associated_report_visible:
+            try:
+                asos_chart_list = self.backend.request(
+                    "GET",
+                    context,
+                    f"/app/{app_key}/asosChart",
+                    params={"role": role, "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,
+                    "loaded": True,
+                    "count": len(associated_items),
+                    "items": associated_items,
+                    "warnings": [],
+                }
+            except QingflowApiError as exc:
+                if not _is_task_optional_read_error(exc):
+                    raise
+                associated_reports = {
+                    "visible": True,
+                    "loaded": False,
+                    "count": 0,
+                    "items": [],
+                    "warnings": [
+                        {
+                            "code": "TASK_ASSOCIATED_REPORTS_UNAVAILABLE",
+                            "message": "Associated reports are not readable in this permission context; task detail remains available.",
+                            "backend_code": exc.backend_code,
+                            "request_id": exc.request_id,
+                            "http_status": exc.http_status,
+                        }
+                    ],
+                }
         rollback_items: list[dict[str, Any]] = []
+        rollback_warnings: list[JSONObject] = []
         transfer_items: list[dict[str, Any]] = []
         transfer_warnings: list[JSONObject] = []
         transfer_pagination: JSONObject = {
@@ -1628,13 +1832,26 @@ class TaskContextTools(ToolBase):
             "truncated": False,
         }
         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)
+            try:
+                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)
+            except QingflowApiError as exc:
+                if not _is_task_optional_read_error(exc):
+                    raise
+                rollback_warnings.append(
+                    {
+                        "code": "TASK_ROLLBACK_CANDIDATES_UNAVAILABLE",
+                        "message": "Rollback candidates are not readable in this permission context; task detail remains available.",
+                        "backend_code": exc.backend_code,
+                        "request_id": exc.request_id,
+                        "http_status": exc.http_status,
+                    }
+                )
             transfer_items, transfer_warnings, transfer_pagination = self._transfer_candidate_items(
                 context,
                 app_key=app_key,
@@ -1657,6 +1874,7 @@ class TaskContextTools(ToolBase):
             context,
             app_key=app_key,
             workflow_node_id=workflow_node_id,
+            node_info=node_info,
         )
         capabilities = self._build_capabilities(
             node_info,
@@ -1703,7 +1921,9 @@ class TaskContextTools(ToolBase):
                 "transfer_members": transfer_items,
                 "loaded": include_candidates,
                 "transfer_pagination": transfer_pagination,
-                "warnings": transfer_warnings,
+                "rollback_warnings": rollback_warnings,
+                "transfer_warnings": transfer_warnings,
+                "warnings": [*rollback_warnings, *transfer_warnings],
             },
             "workflow_log_summary": {
                 "visible": visibility["audit_record_visible"],
@@ -1712,6 +1932,7 @@ class TaskContextTools(ToolBase):
                 "qrobot_log_visible": visibility["qrobot_record_visible"],
             },
             "update_schema": update_schema,
+            "warnings": context_warnings,
         }
 
     def _compact_task_get_context(self, data: dict[str, Any]) -> dict[str, Any]:
@@ -1781,12 +2002,14 @@ class TaskContextTools(ToolBase):
                     "loaded": bool(associated_reports.get("loaded")),
                     "count": len(associated_items),
                     "items": associated_items,
+                    "warnings": associated_reports.get("warnings") or [],
                 },
                 "rollback_candidates": {
                     "available": "rollback" in available_actions,
                     "loaded": bool(candidates.get("loaded")),
                     "count": len(rollback_items),
                     "items": rollback_items,
+                    "warnings": candidates.get("rollback_warnings") or [],
                 },
                 "transfer_candidates": {
                     "available": "transfer" in available_actions,
@@ -1794,7 +2017,7 @@ class TaskContextTools(ToolBase):
                     "count": len(transfer_items),
                     "items": transfer_items,
                     "pagination": transfer_pagination,
-                    "warnings": candidates.get("warnings") or [],
+                    "warnings": candidates.get("transfer_warnings") or [],
                 },
             },
         }
@@ -1829,6 +2052,8 @@ class TaskContextTools(ToolBase):
             metadata["blockers"] = blockers
         if warnings:
             metadata["warnings"] = warnings
+        if update_schema.get("editable_question_ids_source"):
+            metadata["editable_question_ids_source"] = update_schema.get("editable_question_ids_source")
         return metadata
 
     def _compact_initiator(self, payload: Any) -> dict[str, Any] | None:
@@ -1877,7 +2102,9 @@ class TaskContextTools(ToolBase):
     ) -> str | None:
         try:
             base_info = self.backend.request("GET", context, f"/app/{app_key}/baseInfo")
-        except QingflowApiError:
+        except QingflowApiError as exc:
+            if not _is_task_optional_read_error(exc):
+                raise
             return None
         if not isinstance(base_info, dict):
             return None
@@ -1895,7 +2122,9 @@ class TaskContextTools(ToolBase):
     ) -> str | None:
         try:
             visible_apps = self.backend.request("GET", context, "/tag/apps")
-        except QingflowApiError:
+        except QingflowApiError as exc:
+            if not _is_task_optional_read_error(exc):
+                raise
             return None
         return self._find_task_app_name_in_visible_apps(visible_apps, app_key=app_key)
 
@@ -2095,6 +2324,54 @@ class TaskContextTools(ToolBase):
             )
         )
 
+    def _fallback_task_node_from_detail(
+        self,
+        detail: dict[str, Any],
+        *,
+        workflow_node_id: int,
+        source_error: QingflowApiError,
+    ) -> dict[str, Any]:
+        """Build a conservative task node snapshot from the readable task detail."""
+        node_info: dict[str, Any] = {
+            "auditNodeId": workflow_node_id,
+            "nodeId": workflow_node_id,
+            "auditNodeName": (
+                detail.get("auditNodeName")
+                or detail.get("nodeName")
+                or detail.get("workflowNodeName")
+                or detail.get("currentNodeName")
+            ),
+            "_auditInfoUnavailable": True,
+            "_auditInfoError": {
+                "http_status": source_error.http_status,
+                "backend_code": source_error.backend_code,
+                "category": source_error.category,
+            },
+        }
+        for key in (
+            "canTransfer",
+            "canRevert",
+            "canUrge",
+            "rejectBtnStatus",
+            "canRevoke",
+            "beingEndWorkflow",
+            "beingCanApplyAgain",
+            "beingSubmitCheck",
+            "beingSubmitPreview",
+            "feedbackRequiredOperationType",
+            "queAuthSetting",
+            "auditRecordVisible",
+            "qrobotRecordBeingVisible",
+            "beingWorkflowNodeFutureListVisible",
+            "commentStatus",
+            "asosChartVisible",
+        ):
+            if key in detail:
+                node_info[key] = detail[key]
+        if "viewAsosChartVisible" in detail and "asosChartVisible" not in node_info:
+            node_info["asosChartVisible"] = detail.get("viewAsosChartVisible")
+        return node_info
+
     def _build_capabilities(
         self,
         node_info: dict[str, Any],
@@ -2159,35 +2436,18 @@ class TaskContextTools(ToolBase):
         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_text,
-                    "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",
-            }
+            if not _is_task_optional_read_error(error):
+                raise
+            return self._build_task_update_schema_from_runtime_answers(
+                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,
+                source_error=error,
+            )
 
         question_relations = _collect_question_relations(app_schema)
         linked_field_ids = _collect_linked_required_field_ids(question_relations)
@@ -2260,6 +2520,7 @@ class TaskContextTools(ToolBase):
                 "record_id": record_id_text,
                 "workflow_node_id": workflow_node_id,
             },
+            "editable_question_ids_source": source,
         }
         return {
             "public_schema": public_schema,
@@ -2269,6 +2530,96 @@ class TaskContextTools(ToolBase):
             "editable_question_ids_source": source,
         }
 
+    def _build_task_update_schema_from_runtime_answers(
+        self,
+        *,
+        profile: str,
+        context: BackendRequestContext,
+        app_key: str,
+        record_id: int,
+        workflow_node_id: int,
+        node_info: dict[str, Any],
+        current_answers: Any,
+        source_error: QingflowApiError,
+    ) -> dict[str, Any]:
+        """Build node-scoped edit schema from the task detail when app schema is unavailable."""
+        record_id_text = stringify_backend_id(record_id)
+        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,
+        )
+        schema_warnings.insert(
+            0,
+            {
+                "code": "TASK_UPDATE_SCHEMA_APP_SCHEMA_UNAVAILABLE",
+                "message": "task update schema used current task answers because the app applicant schema was unavailable in this permission context.",
+                "transport_error": {
+                    "http_status": source_error.http_status,
+                    "backend_code": source_error.backend_code,
+                    "category": source_error.category,
+                },
+            },
+        )
+        index = _build_answer_backed_field_index(
+            current_answers,
+            field_id_filter={str(que_id) for que_id in editable_question_ids if que_id > 0},
+        )
+        effective_editable_ids = set(editable_question_ids)
+        writable_fields: list[JSONObject] = []
+        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_field = self._record_tools._ready_schema_field_payload(
+                profile,
+                context,
+                editable_field,
+                ws_id=context.ws_id,
+                required_override=False,
+                linkage_payloads_by_field_id={},
+            )
+            writable_field.setdefault("field_id", editable_field.que_id)
+            writable_fields.append(writable_field)
+
+        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 in the current task detail.",
+                }
+            )
+        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_text,
+                "workflow_node_id": workflow_node_id,
+            },
+            "editable_question_ids_source": f"{source}_runtime_answers",
+        }
+        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": f"{source}_runtime_answers",
+        }
+
     def _augment_task_editable_field_index(
         self,
         *,
@@ -2328,12 +2679,15 @@ class TaskContextTools(ToolBase):
             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:
+            if not _is_task_optional_read_error(error):
                 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.",
+                    "backend_code": error.backend_code,
+                    "http_status": error.http_status,
+                    "request_id": error.request_id,
                 }
             )
         fallback_ids = self._editable_ids_from_que_auth_setting(node_info.get("queAuthSetting"))
@@ -2345,6 +2699,7 @@ class TaskContextTools(ToolBase):
         *,
         app_key: str,
         workflow_node_id: int,
+        node_info: dict[str, Any],
     ) -> tuple[bool, list[JSONObject], str]:
         """执行内部辅助逻辑。"""
         try:
@@ -2354,15 +2709,28 @@ class TaskContextTools(ToolBase):
                 f"/app/{app_key}/auditNode/{workflow_node_id}/editableQueIds",
             )
         except QingflowApiError as error:
+            if not _is_task_optional_read_error(error):
+                raise
+            fallback_ids = self._editable_ids_from_que_auth_setting(node_info.get("queAuthSetting"))
+            fallback_source = "que_auth_setting" if fallback_ids else "backend_editable_que_ids_unavailable"
             warning: JSONObject = {
-                "code": "TASK_SAVE_ONLY_SIGNAL_UNAVAILABLE",
-                "message": "save_only is hidden because backend editableQueIds is unavailable for the current node; MCP no longer infers save_only from local schema reconstruction.",
+                "code": "TASK_SAVE_ONLY_EDITABLE_IDS_FALLBACK" if fallback_ids else "TASK_SAVE_ONLY_SIGNAL_UNAVAILABLE",
+                "message": (
+                    "save_only availability used current task queAuthSetting because backend editableQueIds was unavailable in this permission context."
+                    if fallback_ids
+                    else "save_only is hidden because backend editableQueIds is unavailable and current task detail does not expose editable fields."
+                ),
             }
             if error.backend_code is not None:
                 warning["backend_code"] = error.backend_code
             if error.http_status is not None:
                 warning["http_status"] = error.http_status
-            return False, [warning], "backend_editable_que_ids_unavailable"
+            if error.request_id is not None:
+                warning["request_id"] = error.request_id
+            if fallback_ids:
+                warning["field_ids"] = sorted(fallback_ids)
+                return True, [warning], fallback_source
+            return False, [warning], fallback_source
         return bool(self._extract_question_ids(payload)), [], "workflow_editable_que_ids"
 
     def _extract_question_ids(self, payload: Any) -> set[int]:
@@ -2655,12 +3023,33 @@ class TaskContextTools(ToolBase):
         warnings: list[JSONObject] = []
 
         while page_num <= max_pages:
-            result = self.backend.request(
-                "GET",
-                context,
-                f"/app/{app_key}/apply/{record_id}/transfer/member",
-                params={"pageNum": page_num, "pageSize": page_size, "auditNodeId": workflow_node_id},
-            )
+            try:
+                result = self.backend.request(
+                    "GET",
+                    context,
+                    f"/app/{app_key}/apply/{record_id}/transfer/member",
+                    params={"pageNum": page_num, "pageSize": page_size, "auditNodeId": workflow_node_id},
+                )
+            except QingflowApiError as exc:
+                if not _is_task_optional_read_error(exc):
+                    raise
+                warnings.append(
+                    {
+                        "code": "TASK_TRANSFER_CANDIDATES_UNAVAILABLE",
+                        "message": "Transfer candidates are not readable in this permission context; task detail remains available.",
+                        "backend_code": exc.backend_code,
+                        "request_id": exc.request_id,
+                        "http_status": exc.http_status,
+                    }
+                )
+                return items, warnings, {
+                    "loaded": False,
+                    "page_size": page_size,
+                    "fetched_pages": fetched_pages,
+                    "reported_total": reported_total,
+                    "page_amount": page_amount,
+                    "truncated": False,
+                }
             fetched_pages += 1
             raw_items = _approval_page_items(result)
             fetched_raw_count += len(raw_items)
@@ -2825,7 +3214,9 @@ class TaskContextTools(ToolBase):
                 context,
                 f"/chart/{chart_key}/auth",
             )
-        except QingflowApiError:
+        except QingflowApiError as error:
+            if not _is_task_optional_read_error(error):
+                raise
             return False
         if not isinstance(auth, dict):
             return False
@@ -3002,3 +3393,62 @@ class TaskContextTools(ToolBase):
             "qf_version": context.qf_version,
             "qf_version_source": context.qf_version_source or ("context" if context.qf_version else "unknown"),
         }
+
+
+def _is_optional_task_audit_info_error(error: QingflowApiError) -> bool:
+    """Whether task auditInfo may be replaced by current task detail."""
+    if is_auth_like_error(error):
+        return False
+    return _is_task_permission_context_error(error) or error.http_status == 404
+
+
+def _task_box_record_list_type(task_box: str | None) -> int:
+    normalized = str(task_box or "todo").strip().lower()
+    if normalized == "initiated":
+        return 14
+    if normalized == "done":
+        return 2
+    if normalized == "cc":
+        return 12
+    return 1
+
+
+def _task_box_record_role(task_box: str | None) -> int:
+    normalized = str(task_box or "todo").strip().lower()
+    if normalized == "initiated":
+        return 2
+    return 3
+
+
+def _is_optional_task_box_locator_error(error: QingflowApiError) -> bool:
+    """Whether one task box may be skipped while resolving a task_id."""
+    if is_auth_like_error(error):
+        return False
+    return _is_task_permission_context_error(error) or error.http_status == 404
+
+
+def _is_task_optional_read_error(error: QingflowApiError) -> bool:
+    if is_auth_like_error(error):
+        return False
+    backend_code = _task_backend_code(error)
+    return backend_code in {40002, 40027, 404} or error.http_status == 404
+
+
+def _is_task_permission_context_error(error: QingflowApiError) -> bool:
+    if is_auth_like_error(error):
+        return False
+    return _task_backend_code(error) in {40002, 40027}
+
+
+def _is_permission_context_error_payload(payload: dict[str, Any]) -> bool:
+    if str(payload.get("category") or "").strip().lower() == "auth":
+        return False
+    if message_looks_like_invalid_token(payload.get("message")):
+        return False
+    if backend_code_value_int(payload.get("http_status")) == 401:
+        return False
+    return backend_code_value_int(payload.get("backend_code")) in {40002, 40027}
+
+
+def _task_backend_code(error: QingflowApiError) -> int | None:
+    return backend_code_int(error)