@qingflow-tech/qingflow-app-builder-mcp 1.0.2 → 1.0.4

package/src/qingflow_mcp/tools/task_context_tools.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import re
 from typing import Any
 from uuid import uuid4
 
@@ -9,6 +10,7 @@ from mcp.server.fastmcp import FastMCP
 from ..backend_client import BackendRequestContext
 from ..config import DEFAULT_PROFILE
 from ..errors import QingflowApiError, 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
@@ -52,10 +54,16 @@ class TaskContextTools(ToolBase):
         self._task_tools = TaskTools(sessions, backend)
         self._approval_tools = ApprovalTools(sessions, backend)
         self._record_tools = RecordTools(sessions, backend)
+        self._app_name_cache: dict[str, str | None] = {}
 
     def register(self, mcp: FastMCP) -> None:
         """注册当前工具到 MCP 服务。"""
-        @mcp.tool()
+        @mcp.tool(
+            description=(
+                "List workflow tasks. `query` first uses backend task search; if the backend returns zero rows, "
+                "public task_list falls back to local matching on app_name, workflow_node_name, app_key, and record_id."
+            )
+        )
         def task_list(
             profile: str = DEFAULT_PROFILE,
             task_box: str = "todo",
@@ -80,14 +88,16 @@ class TaskContextTools(ToolBase):
         @mcp.tool()
         def task_get(
             profile: str = DEFAULT_PROFILE,
+            task_id: str = "",
             app_key: str = "",
-            record_id: int = 0,
+            record_id: str = "",
             workflow_node_id: int = 0,
             include_candidates: bool = True,
             include_associated_reports: bool = True,
         ) -> dict[str, Any]:
             return self.task_get(
                 profile=profile,
+                task_id=task_id,
                 app_key=app_key,
                 record_id=record_id,
                 workflow_node_id=workflow_node_id,
@@ -98,8 +108,9 @@ class TaskContextTools(ToolBase):
         @mcp.tool(description=self._high_risk_tool_description(operation="execute", target="workflow task action"))
         def task_action_execute(
             profile: str = DEFAULT_PROFILE,
+            task_id: str = "",
             app_key: str = "",
-            record_id: int = 0,
+            record_id: str = "",
             workflow_node_id: int = 0,
             action: str = "",
             payload: dict[str, Any] | None = None,
@@ -107,6 +118,7 @@ class TaskContextTools(ToolBase):
         ) -> dict[str, Any]:
             return self.task_action_execute(
                 profile=profile,
+                task_id=task_id,
                 app_key=app_key,
                 record_id=record_id,
                 workflow_node_id=workflow_node_id,
@@ -118,8 +130,9 @@ class TaskContextTools(ToolBase):
         @mcp.tool()
         def task_associated_report_detail_get(
             profile: str = DEFAULT_PROFILE,
+            task_id: str = "",
             app_key: str = "",
-            record_id: int = 0,
+            record_id: str = "",
             workflow_node_id: int = 0,
             report_id: int = 0,
             page: int = 1,
@@ -127,6 +140,7 @@ class TaskContextTools(ToolBase):
         ) -> dict[str, Any]:
             return self.task_associated_report_detail_get(
                 profile=profile,
+                task_id=task_id,
                 app_key=app_key,
                 record_id=record_id,
                 workflow_node_id=workflow_node_id,
@@ -138,12 +152,14 @@ class TaskContextTools(ToolBase):
         @mcp.tool()
         def task_workflow_log_get(
             profile: str = DEFAULT_PROFILE,
+            task_id: str = "",
             app_key: str = "",
-            record_id: int = 0,
+            record_id: str = "",
             workflow_node_id: int = 0,
         ) -> dict[str, Any]:
             return self.task_workflow_log_get(
                 profile=profile,
+                task_id=task_id,
                 app_key=app_key,
                 record_id=record_id,
                 workflow_node_id=workflow_node_id,
@@ -163,44 +179,63 @@ class TaskContextTools(ToolBase):
         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(
+        response = self._list_normalized_task_items(
             profile=profile,
-            type=normalized_type,
-            process_status=normalized_status,
+            task_box=task_box,
+            flow_status=flow_status,
             app_key=app_key,
-            node_id=workflow_node_id,
-            search_key=query,
-            page_num=page,
+            workflow_node_id=workflow_node_id,
+            query=query,
+            page=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)
-        ]
+        warnings: list[dict[str, Any]] = []
+        items = response["items"] if isinstance(response.get("items"), list) else []
+        page_amount = response.get("page_amount")
+        reported_total = response.get("reported_total")
+        if query and not items:
+            fallback = self._task_list_local_query_fallback(
+                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,
+            )
+            if fallback is not None:
+                items = fallback["items"]
+                returned_items = len(items)
+                page_amount = fallback["page_amount"]
+                reported_total = fallback["reported_total"]
+                warnings.append(
+                    {
+                        "code": "TASK_LIST_QUERY_FALLBACK_APPLIED",
+                        "message": (
+                            "backend searchKey returned zero tasks; task_list fell back to local matching on "
+                            "app_name, workflow_node_name, app_key, and record_id."
+                        ),
+                    }
+                )
+        public_items = [self._public_task_item(item) for item in items]
         return {
             "profile": profile,
-            "ws_id": raw.get("ws_id"),
+            "ws_id": response.get("raw", {}).get("ws_id") if isinstance(response.get("raw"), dict) else None,
             "ok": True,
-            "request_route": raw.get("request_route"),
-            "warnings": [],
+            "request_route": response.get("raw", {}).get("request_route") if isinstance(response.get("raw"), dict) else None,
+            "warnings": warnings,
             "output_profile": "normal",
             "data": {
-                "items": items,
+                "items": public_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),
+                    "returned_items": len(public_items),
+                    "page_amount": page_amount,
+                    "reported_total": reported_total,
                 },
                 "selection": {
-                    "task_box": task_box,
-                    "flow_status": flow_status,
                     "app_key": app_key,
                     "workflow_node_id": workflow_node_id,
                     "query": query,
@@ -213,26 +248,44 @@ class TaskContextTools(ToolBase):
         self,
         *,
         profile: str,
-        app_key: str,
-        record_id: int,
-        workflow_node_id: int,
-        include_candidates: bool,
-        include_associated_reports: bool,
+        task_id: Any = None,
+        app_key: str = "",
+        record_id: Any = "",
+        workflow_node_id: int = 0,
+        include_candidates: bool = True,
+        include_associated_reports: bool = True,
     ) -> dict[str, Any]:
         """执行任务相关逻辑。"""
-        self._require_app_record_and_node(app_key, record_id, workflow_node_id)
+        if task_id in (None, ""):
+            normalize_positive_id_int(record_id, field_name="record_id")
 
         def runner(session_profile, context):
-            data = self._build_task_context(
+            locator = self._resolve_task_locator_input(
                 profile=profile,
-                context=context,
+                task_id=task_id,
                 app_key=app_key,
                 record_id=record_id,
                 workflow_node_id=workflow_node_id,
+            )
+            task_id_text = locator["task_id"]
+            resolved_app_key = str(locator["app_key"])
+            resolved_record_id = int(locator["record_id"])
+            resolved_workflow_node_id = int(locator["workflow_node_id"])
+            self._require_app_record_and_node(resolved_app_key, resolved_record_id, resolved_workflow_node_id)
+            data = self._build_task_context(
+                profile=profile,
+                context=context,
+                app_key=resolved_app_key,
+                record_id=resolved_record_id,
+                workflow_node_id=resolved_workflow_node_id,
                 include_candidates=include_candidates,
                 include_associated_reports=include_associated_reports,
                 current_uid=session_profile.uid,
             )
+            data = self._compact_task_get_context(data)
+            task_payload = data.get("task")
+            if isinstance(task_payload, dict) and task_id_text is not None:
+                task_payload["task_id"] = task_id_text
             return {
                 "profile": profile,
                 "ws_id": session_profile.selected_ws_id,
@@ -251,7 +304,7 @@ class TaskContextTools(ToolBase):
         *,
         profile: str,
         app_key: str,
-        record_id: int,
+        record_id: Any,
         workflow_node_id: int,
         fields: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
@@ -274,15 +327,18 @@ class TaskContextTools(ToolBase):
         self,
         *,
         profile: str,
-        app_key: str,
-        record_id: int,
-        workflow_node_id: int,
+        task_id: Any = None,
+        app_key: str = "",
+        record_id: Any = "",
+        workflow_node_id: int = 0,
         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)
+        if task_id in (None, ""):
+            normalize_positive_id_int(record_id, field_name="record_id")
+
         normalized_action = (action or "").strip().lower()
         if normalized_action not in {"approve", "reject", "rollback", "transfer", "urge", "save_only"}:
             raise_tool_error(
@@ -300,13 +356,27 @@ class TaskContextTools(ToolBase):
             )
 
         def runner(session_profile, context):
+            locator = self._resolve_task_locator_input(
+                profile=profile,
+                task_id=task_id,
+                app_key=app_key,
+                record_id=record_id,
+                workflow_node_id=workflow_node_id,
+            )
+            task_id_text = locator["task_id"]
+            resolved_app_key = str(locator["app_key"])
+            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"])
+            record_id_text = resolved_record_id_text
+            self._require_app_record_and_node(resolved_app_key, resolved_record_id, resolved_workflow_node_id)
             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,
+                    app_key=resolved_app_key,
+                    record_id=resolved_record_id,
+                    workflow_node_id=resolved_workflow_node_id,
                     include_candidates=False,
                     include_associated_reports=False,
                     current_uid=session_profile.uid,
@@ -317,12 +387,13 @@ class TaskContextTools(ToolBase):
                         profile=profile,
                         session_profile=session_profile,
                         context=context,
-                        app_key=app_key,
-                        record_id=record_id,
-                        workflow_node_id=workflow_node_id,
+                        app_key=resolved_app_key,
+                        record_id=resolved_record_id,
+                        workflow_node_id=resolved_workflow_node_id,
                         action=normalized_action,
                         source_error=error,
                         before_apply_status=None,
+                        task_id=task_id_text,
                     )
                 raise
             if normalized_action == "save_only" and not field_updates:
@@ -351,7 +422,7 @@ class TaskContextTools(ToolBase):
                     raise_tool_error(QingflowApiError.config_error(message))
                 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}"
+                        f"task action '{normalized_action}' is not currently available for app_key='{resolved_app_key}' record_id={record_id_text} workflow_node_id={resolved_workflow_node_id}"
                     )
                 )
             feedback_required_for = capabilities.get("action_constraints", {}).get("feedback_required_for") or []
@@ -372,9 +443,9 @@ class TaskContextTools(ToolBase):
                 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,
+                    app_key=resolved_app_key,
+                    record_id=resolved_record_id,
+                    workflow_node_id=resolved_workflow_node_id,
                     task_context=task_context,
                     fields=field_updates,
                 )
@@ -384,16 +455,16 @@ class TaskContextTools(ToolBase):
                 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,
+                    app_key=resolved_app_key,
+                    record_id=resolved_record_id,
+                    workflow_node_id=resolved_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,
+                    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=prepared_fields,
@@ -404,21 +475,22 @@ class TaskContextTools(ToolBase):
                         profile=profile,
                         session_profile=session_profile,
                         context=context,
-                        app_key=app_key,
-                        record_id=record_id,
-                        workflow_node_id=workflow_node_id,
+                        app_key=resolved_app_key,
+                        record_id=resolved_record_id,
+                        workflow_node_id=resolved_workflow_node_id,
                         action=normalized_action,
                         source_error=error,
                         before_apply_status=before_apply_status,
+                        task_id=task_id_text,
                     )
                 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,
+                    app_key=resolved_app_key,
+                    record_id=resolved_record_id,
+                    workflow_node_id=resolved_workflow_node_id,
                     before_apply_status=before_apply_status,
                     expected_answers=((prepared_fields or {}).get("normalized_answers") or []),
                     task_context=task_context,
@@ -430,9 +502,9 @@ class TaskContextTools(ToolBase):
                 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,
+                    app_key=resolved_app_key,
+                    record_id=resolved_record_id,
+                    workflow_node_id=resolved_workflow_node_id,
                     action=normalized_action,
                     before_apply_status=before_apply_status,
                     runtime_baseline=runtime_baseline,
@@ -440,7 +512,7 @@ class TaskContextTools(ToolBase):
                 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 {
+            result = {
                 "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",
@@ -453,9 +525,9 @@ class TaskContextTools(ToolBase):
                 "data": {
                     "action": normalized_action,
                     "resource": {
-                        "app_key": app_key,
-                        "record_id": record_id,
-                        "workflow_node_id": workflow_node_id,
+                        "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"),
@@ -463,6 +535,11 @@ class TaskContextTools(ToolBase):
                     "field_update_applied": bool(field_updates),
                 },
             }
+            if task_id_text is not None:
+                resource = result["data"].get("resource")
+                if isinstance(resource, dict):
+                    resource["task_id"] = task_id_text
+            return result
 
         return self._run(profile, runner)
 
@@ -471,7 +548,7 @@ class TaskContextTools(ToolBase):
         *,
         profile: str,
         app_key: str,
-        record_id: int,
+        record_id: Any,
         workflow_node_id: int,
         normalized_action: str,
         payload: dict[str, Any],
@@ -635,12 +712,12 @@ class TaskContextTools(ToolBase):
         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
+            ids_equal(item.get("record_id"), 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
+            ids_equal(item.get("record_id"), record_id)
             for item in initiated_items
             if isinstance(item, dict)
         )
@@ -657,7 +734,7 @@ class TaskContextTools(ToolBase):
             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 ids_equal(item.get("record_id"), record_id)
             and int(item.get("workflow_node_id") or 0) != workflow_node_id
         }
         workflow_log_digest = self._workflow_log_digest(log_items)
@@ -675,6 +752,25 @@ class TaskContextTools(ToolBase):
             or verification.get("downstream_todo_changed")
             or verification.get("workflow_log_advanced")
         )
+        record_state_error = verification.get("record_state_error")
+        runtime_consumed_after_action = bool(
+            runtime_verified
+            and isinstance(record_state_error, dict)
+            and record_state_error.get("backend_code") == 46001
+        )
+        if runtime_consumed_after_action:
+            verification["record_state_scope"] = "current_node_runtime"
+            verification["record_state_unavailable_reason"] = "runtime_consumed_after_action"
+            verification["record_state_unavailability_expected"] = True
+            warnings.append(
+                {
+                    "code": "TASK_RUNTIME_CONSUMED_AFTER_ACTION",
+                    "message": (
+                        "the current workflow node runtime is no longer readable after the action (backend 46001), "
+                        "which usually means the node has been consumed and the workflow has already continued."
+                    ),
+                }
+            )
         verification["runtime_continuation_verified"] = runtime_verified
         if not runtime_verified:
             warnings.append(
@@ -843,7 +939,7 @@ class TaskContextTools(ToolBase):
                 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 ids_equal(item.get("record_id"), record_id)
                 and int(item.get("workflow_node_id") or 0) != workflow_node_id
             }
         )
@@ -861,8 +957,10 @@ class TaskContextTools(ToolBase):
         action: str,
         source_error: QingflowApiError,
         before_apply_status: Any,
+        task_id: str | None = None,
     ) -> dict[str, Any]:
         """执行内部辅助逻辑。"""
+        record_id_text = stringify_backend_id(record_id)
         verification, warnings = self._verify_task_action_runtime(
             profile=profile,
             context=context,
@@ -881,7 +979,7 @@ class TaskContextTools(ToolBase):
                     "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 {
+            result = {
                 "profile": profile,
                 "ws_id": session_profile.selected_ws_id,
                 "ok": True,
@@ -895,7 +993,7 @@ class TaskContextTools(ToolBase):
                     "action": action,
                     "resource": {
                         "app_key": app_key,
-                        "record_id": record_id,
+                        "record_id": record_id_text,
                         "workflow_node_id": workflow_node_id,
                     },
                     "selection": {"action": action},
@@ -903,13 +1001,18 @@ class TaskContextTools(ToolBase):
                     "human_review": True,
                 },
             }
+            if task_id is not None:
+                resource = result["data"].get("resource")
+                if isinstance(resource, dict):
+                    resource["task_id"] = task_id
+            return result
         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 {
+        result = {
             "profile": profile,
             "ws_id": session_profile.selected_ws_id,
             "ok": False,
@@ -923,7 +1026,7 @@ class TaskContextTools(ToolBase):
                 "action": action,
                 "resource": {
                     "app_key": app_key,
-                    "record_id": record_id,
+                    "record_id": record_id_text,
                     "workflow_node_id": workflow_node_id,
                 },
                 "selection": {"action": action},
@@ -936,11 +1039,16 @@ class TaskContextTools(ToolBase):
                 },
             },
         }
+        if task_id is not None:
+            resource = result["data"].get("resource")
+            if isinstance(resource, dict):
+                resource["task_id"] = task_id
+        return result
 
     def _safe_task_list_items(self, *, profile: str, task_box: str, app_key: str) -> list[dict[str, Any]]:
         """执行内部辅助逻辑。"""
         try:
-            response = self.task_list(
+            response = self._list_normalized_task_items(
                 profile=profile,
                 task_box=task_box,
                 flow_status="all",
@@ -952,38 +1060,260 @@ class TaskContextTools(ToolBase):
             )
         except QingflowApiError:
             return []
-        data = response.get("data") if isinstance(response, dict) else None
-        items = data.get("items") if isinstance(data, dict) else None
+        items = response.get("items") if isinstance(response, dict) else None
         if not isinstance(items, list):
             return []
         return [item for item in items if isinstance(item, dict)]
 
+    def _list_normalized_task_items(
+        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", {})
+        return {
+            "raw": raw,
+            "items": [self._normalize_task_item(item) for item in _task_page_items(task_page) if isinstance(item, dict)],
+            "page_amount": _task_page_amount(task_page),
+            "reported_total": _task_page_total(task_page),
+        }
+
+    def _task_list_local_query_fallback(
+        self,
+        *,
+        profile: str,
+        task_box: str,
+        flow_status: str,
+        app_key: str | None,
+        workflow_node_id: int | None,
+        query: str,
+        page: int,
+        page_size: int,
+    ) -> dict[str, Any] | None:
+        scan_page_size = max(page_size, 100)
+        scan_page = 1
+        page_amount: int | None = None
+        matched_items: list[dict[str, Any]] = []
+        while True:
+            response = self._list_normalized_task_items(
+                profile=profile,
+                task_box=task_box,
+                flow_status=flow_status,
+                app_key=app_key,
+                workflow_node_id=workflow_node_id,
+                query=None,
+                page=scan_page,
+                page_size=scan_page_size,
+            )
+            normalized_items = response.get("items") if isinstance(response.get("items"), list) else []
+            matched_items.extend(item for item in normalized_items if self._task_item_matches_query(item, query))
+            if page_amount is None:
+                coerced_page_amount = _coerce_count(response.get("page_amount"))
+                if coerced_page_amount is not None and coerced_page_amount > 0:
+                    page_amount = coerced_page_amount
+            if page_amount is not None and scan_page >= page_amount:
+                break
+            if not normalized_items or len(normalized_items) < scan_page_size:
+                break
+            scan_page += 1
+        if not matched_items:
+            return None
+        start = max(page - 1, 0) * page_size
+        end = start + page_size
+        matched_total = len(matched_items)
+        matched_page_amount = (matched_total + page_size - 1) // page_size if page_size > 0 else 0
+        return {
+            "items": matched_items[start:end],
+            "page_amount": matched_page_amount,
+            "reported_total": matched_total,
+        }
+
+    def _resolve_task_locator_by_task_id(self, *, profile: str, task_id: Any) -> dict[str, Any]:
+        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] = []
+        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,
+                )
+                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):
+                        continue
+                    app_key = str(item.get("app_key") or "").strip()
+                    record_id = stringify_backend_id(item.get("record_id"))
+                    workflow_node_id = int(item.get("workflow_node_id") or 0)
+                    if not app_key or record_id is None or workflow_node_id <= 0:
+                        incomplete_task_boxes.append(task_box)
+                        continue
+                    return {
+                        "task_id": task_id_text,
+                        "task_box": task_box,
+                        "app_key": app_key,
+                        "record_id": record_id,
+                        "workflow_node_id": workflow_node_id,
+                    }
+                if page_amount is None:
+                    coerced_page_amount = _coerce_count(response.get("page_amount"))
+                    if coerced_page_amount is not None and coerced_page_amount > 0:
+                        page_amount = coerced_page_amount
+                if page_amount is not None and page >= page_amount:
+                    break
+                if not items or len(items) < page_size:
+                    break
+                page += 1
+        if incomplete_task_boxes:
+            searched = ", ".join(incomplete_task_boxes)
+            raise_tool_error(
+                QingflowApiError.config_error(
+                    f"task_id={task_id_text} resolved to an incomplete task locator in task_box={searched}; please refresh the task list and retry"
+                )
+            )
+        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)"
+            )
+        )
+
+    def _resolve_task_locator_input(
+        self,
+        *,
+        profile: str,
+        task_id: Any = None,
+        app_key: str = "",
+        record_id: Any = "",
+        workflow_node_id: int = 0,
+    ) -> dict[str, Any]:
+        task_id_text = normalize_positive_id_text(task_id, field_name="task_id") if task_id not in (None, "") else None
+        resolved_app_key = (app_key or "").strip()
+        resolved_record_id: int
+        resolved_workflow_node_id: int
+        if task_id_text is not None:
+            locator = self._resolve_task_locator_by_task_id(profile=profile, task_id=task_id_text)
+            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"])
+            explicit_app_key = (app_key or "").strip()
+            if explicit_app_key and explicit_app_key != resolved_app_key:
+                raise_tool_error(
+                    QingflowApiError.config_error(
+                        f"task_id={task_id_text} resolved to app_key='{resolved_app_key}', which does not match app_key='{explicit_app_key}'"
+                    )
+                )
+            if record_id not in (None, ""):
+                explicit_record_id = normalize_positive_id_text(record_id, field_name="record_id")
+                if explicit_record_id != stringify_backend_id(resolved_record_id):
+                    raise_tool_error(
+                        QingflowApiError.config_error(
+                            f"task_id={task_id_text} resolved to record_id={resolved_record_id}, which does not match record_id={explicit_record_id}"
+                        )
+                    )
+            if workflow_node_id not in (None, 0) and int(workflow_node_id) != resolved_workflow_node_id:
+                raise_tool_error(
+                    QingflowApiError.config_error(
+                        f"task_id={task_id_text} resolved to workflow_node_id={resolved_workflow_node_id}, which does not match workflow_node_id={workflow_node_id}"
+                    )
+                )
+        else:
+            resolved_record_id = normalize_positive_id_int(record_id, field_name="record_id")
+            resolved_workflow_node_id = int(workflow_node_id)
+        return {
+            "task_id": task_id_text,
+            "app_key": resolved_app_key,
+            "record_id": resolved_record_id,
+            "record_id_text": stringify_backend_id(resolved_record_id),
+            "workflow_node_id": resolved_workflow_node_id,
+        }
+
+    def _task_item_matches_query(self, item: dict[str, Any], query: str) -> bool:
+        needle = str(query or "").strip().casefold()
+        if not needle:
+            return False
+        for candidate in (
+            item.get("app_name"),
+            item.get("workflow_node_name"),
+            item.get("app_key"),
+            item.get("record_id"),
+        ):
+            if candidate in (None, ""):
+                continue
+            if needle in str(candidate).casefold():
+                return True
+        return False
+
     @tool_cn_name("任务关联报表详情")
     def task_associated_report_detail_get(
         self,
         *,
         profile: str,
-        app_key: str,
-        record_id: int,
-        workflow_node_id: int,
+        task_id: Any = None,
+        app_key: str = "",
+        record_id: Any = "",
+        workflow_node_id: int = 0,
         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 task_id in (None, ""):
+            normalize_positive_id_int(record_id, field_name="record_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(
+            locator = self._resolve_task_locator_input(
                 profile=profile,
-                context=context,
+                task_id=task_id,
                 app_key=app_key,
                 record_id=record_id,
                 workflow_node_id=workflow_node_id,
+            )
+            task_id_text = locator["task_id"]
+            resolved_app_key = str(locator["app_key"])
+            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"])
+            self._require_app_record_and_node(resolved_app_key, resolved_record_id, resolved_workflow_node_id)
+            task_context = self._build_task_context(
+                profile=profile,
+                context=context,
+                app_key=resolved_app_key,
+                record_id=resolved_record_id,
+                workflow_node_id=resolved_workflow_node_id,
                 include_candidates=False,
                 include_associated_reports=True,
                 current_uid=session_profile.uid,
@@ -992,7 +1322,7 @@ class TaskContextTools(ToolBase):
             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}"
+                        f"report_id={report_id} is not visible for app_key='{resolved_app_key}' record_id={record_id_text} workflow_node_id={resolved_workflow_node_id}"
                     )
                 )
             association_query = self._build_association_query(
@@ -1000,15 +1330,17 @@ class TaskContextTools(ToolBase):
                 task_context.get("record", {}).get("answers") or [],
             )
             selection = {
-                "app_key": app_key,
-                "record_id": record_id,
-                "workflow_node_id": workflow_node_id,
+                "app_key": resolved_app_key,
+                "record_id": record_id_text,
+                "workflow_node_id": resolved_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"),
             }
+            if task_id_text is not None:
+                selection["task_id"] = task_id_text
             context_payload = {
                 "match_rules": report_item.get("match_rules") or [],
                 "resolved_filters": association_query.get("keyQueValues") or [],
@@ -1155,20 +1487,35 @@ class TaskContextTools(ToolBase):
         self,
         *,
         profile: str,
-        app_key: str,
-        record_id: int,
-        workflow_node_id: int,
+        task_id: Any = None,
+        app_key: str = "",
+        record_id: Any = "",
+        workflow_node_id: int = 0,
     ) -> dict[str, Any]:
         """执行任务相关逻辑。"""
-        self._require_app_record_and_node(app_key, record_id, workflow_node_id)
+        if task_id in (None, ""):
+            normalize_positive_id_int(record_id, field_name="record_id")
 
         def runner(session_profile, context):
-            task_context = self._build_task_context(
+            locator = self._resolve_task_locator_input(
                 profile=profile,
-                context=context,
+                task_id=task_id,
                 app_key=app_key,
                 record_id=record_id,
                 workflow_node_id=workflow_node_id,
+            )
+            task_id_text = locator["task_id"]
+            resolved_app_key = str(locator["app_key"])
+            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"])
+            self._require_app_record_and_node(resolved_app_key, resolved_record_id, resolved_workflow_node_id)
+            task_context = self._build_task_context(
+                profile=profile,
+                context=context,
+                app_key=resolved_app_key,
+                record_id=resolved_record_id,
+                workflow_node_id=resolved_workflow_node_id,
                 include_candidates=False,
                 include_associated_reports=False,
                 current_uid=session_profile.uid,
@@ -1177,7 +1524,7 @@ class TaskContextTools(ToolBase):
             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}"
+                        f"workflow logs are not visible for app_key='{resolved_app_key}' record_id={record_id_text} workflow_node_id={resolved_workflow_node_id}"
                     )
                 )
             page = self.backend.request(
@@ -1185,16 +1532,16 @@ class TaskContextTools(ToolBase):
                 context,
                 "/application/workflow/node/record",
                 json_body={
-                    "key": app_key,
-                    "rowRecordId": record_id,
-                    "nodeId": workflow_node_id,
+                    "key": resolved_app_key,
+                    "rowRecordId": resolved_record_id,
+                    "nodeId": resolved_workflow_node_id,
                     "role": 3,
                     "pageNum": 1,
                     "pageSize": 200,
                 },
             )
             items = self._normalize_workflow_logs(page)
-            return {
+            result = {
                 "profile": profile,
                 "ws_id": session_profile.selected_ws_id,
                 "ok": True,
@@ -1203,9 +1550,9 @@ class TaskContextTools(ToolBase):
                 "output_profile": "normal",
                 "data": {
                     "selection": {
-                        "app_key": app_key,
-                        "record_id": record_id,
-                        "workflow_node_id": workflow_node_id,
+                        "app_key": resolved_app_key,
+                        "record_id": record_id_text,
+                        "workflow_node_id": resolved_workflow_node_id,
                     },
                     "visibility": {
                         "audit_record_visible": visibility.get("audit_record_visible"),
@@ -1214,6 +1561,11 @@ class TaskContextTools(ToolBase):
                     "items": items,
                 },
             }
+            if task_id_text is not None:
+                selection = result["data"].get("selection")
+                if isinstance(selection, dict):
+                    selection["task_id"] = task_id_text
+            return result
 
         return self._run(profile, runner)
 
@@ -1243,8 +1595,9 @@ class TaskContextTools(ToolBase):
             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, "count": 0, "items": []}
+        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(
                 "GET",
@@ -1259,11 +1612,21 @@ class TaskContextTools(ToolBase):
             ]
             associated_reports = {
                 "visible": True,
+                "loaded": True,
                 "count": len(associated_items),
                 "items": associated_items,
             }
         rollback_items: list[dict[str, Any]] = []
         transfer_items: list[dict[str, Any]] = []
+        transfer_warnings: list[JSONObject] = []
+        transfer_pagination: JSONObject = {
+            "loaded": False,
+            "page_size": 100,
+            "fetched_pages": 0,
+            "reported_total": None,
+            "page_amount": None,
+            "truncated": False,
+        }
         if include_candidates:
             rollback_result = self.backend.request(
                 "GET",
@@ -1272,13 +1635,13 @@ class TaskContextTools(ToolBase):
                 params={"auditNodeId": workflow_node_id},
             )
             rollback_items = self._rollback_candidate_items(rollback_result)
-            transfer_result = self.backend.request(
-                "GET",
+            transfer_items, transfer_warnings, transfer_pagination = self._transfer_candidate_items(
                 context,
-                f"/app/{app_key}/apply/{record_id}/transfer/member",
-                params={"pageNum": 1, "pageSize": 20, "auditNodeId": workflow_node_id},
+                app_key=app_key,
+                record_id=record_id,
+                workflow_node_id=workflow_node_id,
+                current_uid=current_uid,
             )
-            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,
@@ -1302,10 +1665,12 @@ class TaskContextTools(ToolBase):
             save_only_source=save_only_source,
         )
         visibility = self._build_visibility(node_info, detail)
+        record_id_text = stringify_backend_id(record_id)
         return {
             "task": {
                 "app_key": app_key,
-                "record_id": record_id,
+                "app_name": app_name,
+                "record_id": record_id_text,
                 "workflow_node_id": workflow_node_id,
                 "workflow_node_name": node_info.get("auditNodeName") or node_info.get("nodeName"),
                 "actionable": True,
@@ -1316,7 +1681,7 @@ class TaskContextTools(ToolBase):
                 "raw": dict(node_info),
             },
             "record": {
-                "apply_id": detail.get("applyId", record_id),
+                "apply_id": stringify_backend_id(detail.get("applyId") or record_id),
                 "apply_status": detail.get("applyStatus"),
                 "apply_num": detail.get("applyNum"),
                 "custom_apply_num": detail.get("customApplyNum"),
@@ -1336,6 +1701,9 @@ class TaskContextTools(ToolBase):
             "candidates": {
                 "rollback_nodes": rollback_items,
                 "transfer_members": transfer_items,
+                "loaded": include_candidates,
+                "transfer_pagination": transfer_pagination,
+                "warnings": transfer_warnings,
             },
             "workflow_log_summary": {
                 "visible": visibility["audit_record_visible"],
@@ -1346,32 +1714,365 @@ class TaskContextTools(ToolBase):
             "update_schema": update_schema,
         }
 
-    def _normalize_task_item(self, raw: dict[str, Any], *, task_box: str, flow_status: str) -> dict[str, Any]:
+    def _compact_task_get_context(self, data: dict[str, Any]) -> dict[str, Any]:
+        task = data.get("task") if isinstance(data.get("task"), dict) else {}
+        record = data.get("record") if isinstance(data.get("record"), dict) else {}
+        capabilities = data.get("capabilities") if isinstance(data.get("capabilities"), dict) else {}
+        update_schema = data.get("update_schema") if isinstance(data.get("update_schema"), dict) else {}
+        associated_reports = data.get("associated_reports") if isinstance(data.get("associated_reports"), dict) else {}
+        candidates = data.get("candidates") if isinstance(data.get("candidates"), dict) else {}
+        workflow_log = data.get("workflow_log_summary") if isinstance(data.get("workflow_log_summary"), dict) else {}
+
+        available_actions = [
+            str(item)
+            for item in (capabilities.get("available_actions") or [])
+            if str(item).strip()
+        ]
+        writable_fields = update_schema.get("writable_fields") if isinstance(update_schema.get("writable_fields"), list) else []
+        rollback_items = [
+            self._compact_rollback_candidate(item)
+            for item in (candidates.get("rollback_nodes") or [])
+            if isinstance(item, dict)
+        ]
+        transfer_items = [
+            self._compact_transfer_member(item)
+            for item in (candidates.get("transfer_members") or [])
+            if isinstance(item, dict)
+        ]
+        associated_items = [
+            self._compact_associated_report(item)
+            for item in (associated_reports.get("items") or [])
+            if isinstance(item, dict)
+        ]
+        transfer_pagination = candidates.get("transfer_pagination") if isinstance(candidates.get("transfer_pagination"), dict) else {}
+        compact: dict[str, Any] = {
+            "task": {
+                "app_key": task.get("app_key"),
+                "app_name": task.get("app_name"),
+                "record_id": stringify_backend_id(task.get("record_id")),
+                "workflow_node_id": task.get("workflow_node_id"),
+                "workflow_node_name": task.get("workflow_node_name"),
+                "initiator": self._compact_initiator(record.get("apply_user")),
+                "actionable": task.get("actionable"),
+            },
+            "record_summary": {
+                "apply_status": record.get("apply_status"),
+                "apply_num": record.get("apply_num"),
+                "custom_apply_num": record.get("custom_apply_num"),
+                "apply_time": record.get("apply_time"),
+                "last_update_time": record.get("last_update_time"),
+                "core_fields": self._task_record_core_fields(record.get("answers") or []),
+                "all_fields": self._task_record_all_fields(record.get("answers") or []),
+            },
+            "available_actions": available_actions,
+            "editable_fields": [
+                self._compact_task_editable_field(item, update_schema)
+                for item in writable_fields
+                if isinstance(item, dict)
+            ],
+            "extras": {
+                "workflow_log": {
+                    "available": bool(workflow_log.get("available")),
+                    "qrobot_log_visible": bool(workflow_log.get("qrobot_log_visible")),
+                    "history_count": workflow_log.get("history_count"),
+                },
+                "associated_reports": {
+                    "available": bool(associated_reports.get("visible")),
+                    "loaded": bool(associated_reports.get("loaded")),
+                    "count": len(associated_items),
+                    "items": associated_items,
+                },
+                "rollback_candidates": {
+                    "available": "rollback" in available_actions,
+                    "loaded": bool(candidates.get("loaded")),
+                    "count": len(rollback_items),
+                    "items": rollback_items,
+                },
+                "transfer_candidates": {
+                    "available": "transfer" in available_actions,
+                    "loaded": bool(transfer_pagination.get("loaded")),
+                    "count": len(transfer_items),
+                    "items": transfer_items,
+                    "pagination": transfer_pagination,
+                    "warnings": candidates.get("warnings") or [],
+                },
+            },
+        }
+        action_metadata = self._compact_task_action_metadata(capabilities)
+        if action_metadata:
+            compact["action_metadata"] = action_metadata
+        editable_metadata = self._compact_task_editable_metadata(update_schema)
+        if editable_metadata:
+            compact["editable_metadata"] = editable_metadata
+        return compact
+
+    def _compact_task_action_metadata(self, capabilities: dict[str, Any]) -> dict[str, Any]:
+        constraints = capabilities.get("action_constraints") if isinstance(capabilities.get("action_constraints"), dict) else {}
+        metadata: dict[str, Any] = {}
+        feedback_required_for = constraints.get("feedback_required_for") if isinstance(constraints.get("feedback_required_for"), list) else []
+        if feedback_required_for:
+            metadata["feedback_required_for"] = feedback_required_for
+        visible_but_unimplemented = capabilities.get("visible_but_unimplemented_actions")
+        if visible_but_unimplemented:
+            metadata["visible_but_unimplemented_actions"] = visible_but_unimplemented
+        if capabilities.get("save_only_source"):
+            metadata["save_only_source"] = capabilities.get("save_only_source")
+        if capabilities.get("warnings"):
+            metadata["warnings"] = capabilities.get("warnings")
+        return metadata
+
+    def _compact_task_editable_metadata(self, update_schema: dict[str, Any]) -> dict[str, Any]:
+        metadata: dict[str, Any] = {}
+        blockers = update_schema.get("blockers") if isinstance(update_schema.get("blockers"), list) else []
+        warnings = update_schema.get("warnings") if isinstance(update_schema.get("warnings"), list) else []
+        if blockers:
+            metadata["blockers"] = blockers
+        if warnings:
+            metadata["warnings"] = warnings
+        return metadata
+
+    def _compact_initiator(self, payload: Any) -> dict[str, Any] | None:
+        if not isinstance(payload, dict):
+            return None
+        compact = {
+            "uid": payload.get("uid"),
+            "displayName": payload.get("displayName") or payload.get("name") or payload.get("nickName"),
+            "email": payload.get("email"),
+            "mobile": payload.get("mobile"),
+            "headImg": payload.get("headImg"),
+        }
+        return {key: value for key, value in compact.items() if value not in (None, "", [])} or None
+
+    def _task_app_name(
+        self,
+        *,
+        context: BackendRequestContext,
+        app_key: str,
+        detail: dict[str, Any],
+        node_info: dict[str, Any],
+    ) -> Any:
+        for source in (detail, node_info):
+            for key in ("formTitle", "appName", "worksheetName", "appTitle"):
+                value = source.get(key)
+                if value not in (None, ""):
+                    if app_key:
+                        self._app_name_cache[app_key] = str(value)
+                    return value
+        normalized_app_key = str(app_key or "").strip()
+        if not normalized_app_key:
+            return None
+        if normalized_app_key in self._app_name_cache:
+            return self._app_name_cache[normalized_app_key]
+        resolved = self._resolve_task_app_name_from_base_info(context=context, app_key=normalized_app_key)
+        if resolved is None:
+            resolved = self._resolve_task_app_name_from_visible_apps(context=context, app_key=normalized_app_key)
+        self._app_name_cache[normalized_app_key] = resolved
+        return resolved
+
+    def _resolve_task_app_name_from_base_info(
+        self,
+        *,
+        context: BackendRequestContext,
+        app_key: str,
+    ) -> str | None:
+        try:
+            base_info = self.backend.request("GET", context, f"/app/{app_key}/baseInfo")
+        except QingflowApiError:
+            return None
+        if not isinstance(base_info, dict):
+            return None
+        for key in ("formTitle", "title", "appName", "name"):
+            value = str(base_info.get(key) or "").strip()
+            if value:
+                return value
+        return None
+
+    def _resolve_task_app_name_from_visible_apps(
+        self,
+        *,
+        context: BackendRequestContext,
+        app_key: str,
+    ) -> str | None:
+        try:
+            visible_apps = self.backend.request("GET", context, "/tag/apps")
+        except QingflowApiError:
+            return None
+        return self._find_task_app_name_in_visible_apps(visible_apps, app_key=app_key)
+
+    def _find_task_app_name_in_visible_apps(self, payload: Any, *, app_key: str) -> str | None:
+        if isinstance(payload, list):
+            for item in payload:
+                resolved = self._find_task_app_name_in_visible_apps(item, app_key=app_key)
+                if resolved:
+                    return resolved
+            return None
+        if not isinstance(payload, dict):
+            return None
+        candidate_app_key = str(payload.get("appKey") or payload.get("app_key") or "").strip()
+        if candidate_app_key == app_key:
+            for key in ("formTitle", "title", "appName", "name"):
+                value = str(payload.get(key) or "").strip()
+                if value:
+                    return value
+        for value in payload.values():
+            if isinstance(value, (list, dict)):
+                resolved = self._find_task_app_name_in_visible_apps(value, app_key=app_key)
+                if resolved:
+                    return resolved
+        return None
+
+    def _task_record_core_fields(self, answers: Any, *, limit: int = 12) -> dict[str, Any]:
+        return self._task_record_field_map(answers, limit=limit, truncate_text=160)
+
+    def _task_record_all_fields(self, answers: Any) -> dict[str, Any]:
+        return self._task_record_field_map(answers, limit=None, truncate_text=None)
+
+    def _task_record_field_map(
+        self,
+        answers: Any,
+        *,
+        limit: int | None,
+        truncate_text: int | None,
+    ) -> dict[str, Any]:
+        if not isinstance(answers, list):
+            return {}
+        field_map: dict[str, Any] = {}
+        for answer in answers:
+            if not isinstance(answer, dict):
+                continue
+            title = answer.get("queTitle") or answer.get("title") or answer.get("fieldName")
+            if not title:
+                que_id = answer.get("queId")
+                title = f"field_{que_id}" if que_id not in (None, "") else None
+            if not title:
+                continue
+            table_values = answer.get("tableValues") if isinstance(answer.get("tableValues"), list) else []
+            if table_values:
+                value: Any = f"子表格 {len(table_values)} 行"
+            else:
+                values = self._extract_answer_values(answer)
+                if not values:
+                    continue
+                value = values[0] if len(values) == 1 else values
+            if value in (None, "", []):
+                continue
+            field_map[str(title)] = self._compact_task_value(value, truncate_text=truncate_text)
+            if limit is not None and len(field_map) >= limit:
+                break
+        return field_map
+
+    def _compact_task_value(self, value: Any, *, truncate_text: int | None = 160) -> Any:
+        if isinstance(value, list):
+            items = [self._compact_task_value(item, truncate_text=truncate_text) for item in value]
+            if truncate_text is not None:
+                return items[:8]
+            return items
+        text = re.sub(r"<[^>]+>", " ", str(value))
+        text = re.sub(r"\s+", " ", text).strip()
+        if truncate_text is None or len(text) <= truncate_text:
+            return text
+        if truncate_text <= 3:
+            return text[:truncate_text]
+        return text[: truncate_text - 3].rstrip() + "..."
+
+    def _compact_task_editable_field(self, field: dict[str, Any], update_schema: dict[str, Any]) -> dict[str, Any]:
+        payload_template = update_schema.get("payload_template") if isinstance(update_schema.get("payload_template"), dict) else {}
+        title = field.get("title")
+        compact: dict[str, Any] = {}
+        for key in ("field_id", "title", "kind", "required", "candidate_hint"):
+            if key in field:
+                compact[key] = field.get(key)
+        if title in payload_template:
+            compact["template"] = payload_template.get(title)
+        return compact
+
+    def _compact_associated_report(self, item: dict[str, Any]) -> dict[str, Any]:
+        return {
+            key: value
+            for key, value in {
+                "report_id": item.get("report_id"),
+                "chart_key": item.get("chart_key"),
+                "chart_name": item.get("chart_name"),
+                "graph_type": item.get("graph_type"),
+                "source_type": item.get("source_type"),
+                "target_app_key": item.get("target_app_key"),
+                "target_app_name": item.get("target_app_name"),
+            }.items()
+            if value not in (None, "", [])
+        }
+
+    def _compact_rollback_candidate(self, item: dict[str, Any]) -> dict[str, Any]:
+        return {
+            key: value
+            for key, value in {
+                "workflow_node_id": item.get("auditNodeId") or item.get("nodeId"),
+                "workflow_node_name": item.get("auditNodeName") or item.get("nodeName"),
+            }.items()
+            if value not in (None, "", [])
+        }
+
+    def _compact_transfer_member(self, item: dict[str, Any]) -> dict[str, Any]:
+        uid = item.get("uid")
+        if uid is None:
+            uid = item.get("userId") or item.get("memberId") or item.get("id")
+        return {
+            key: value
+            for key, value in {
+                "uid": uid,
+                "name": item.get("name") or item.get("userName") or item.get("memberName") or item.get("realName"),
+                "email": item.get("email") or item.get("mail"),
+                "department_id": item.get("departmentId") or item.get("deptId"),
+                "department_name": item.get("departmentName") or item.get("deptName"),
+            }.items()
+            if value not in (None, "", [])
+        }
+
+    def _normalize_task_item(self, raw: dict[str, Any]) -> 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,
+            "task_id": stringify_backend_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,
+            "record_id": stringify_backend_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),
+            "summary_fields": self._normalize_task_summary_fields(raw.get("dataSnapshot")),
+        }
+
+    def _public_task_item(self, item: dict[str, Any]) -> dict[str, Any]:
+        return {
+            "task_id": item.get("task_id"),
+            "app_name": item.get("app_name"),
+            "workflow_node_name": item.get("workflow_node_name"),
+            "apply_time": item.get("apply_time"),
+            "summary_fields": item.get("summary_fields") if isinstance(item.get("summary_fields"), list) else [],
         }
 
+    def _normalize_task_summary_fields(self, raw: Any) -> list[dict[str, Any]]:
+        """执行内部辅助逻辑。"""
+        if not isinstance(raw, list):
+            return []
+        summary_fields: list[dict[str, Any]] = []
+        for item in raw:
+            if not isinstance(item, dict):
+                continue
+            summary_field: dict[str, Any] = {
+                "field_id": item.get("fieldId"),
+                "title": item.get("fieldTitle"),
+                "type": item.get("fieldType"),
+                "answer": item.get("fieldAnswer"),
+                "desensitized": self._coerce_bool(item.get("beingDesensitized")),
+            }
+            associated_field_type = item.get("associatedQueType")
+            if associated_field_type is not None:
+                summary_field["associated_field_type"] = associated_field_type
+            summary_fields.append(summary_field)
+        return summary_fields
+
     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:
@@ -1454,6 +2155,7 @@ class TaskContextTools(ToolBase):
         current_answers: Any,
     ) -> dict[str, Any]:
         """执行内部辅助逻辑。"""
+        record_id_text = stringify_backend_id(record_id)
         try:
             app_schema = self._record_tools._get_form_schema(profile, context, app_key, force_refresh=False)
         except QingflowApiError as error:
@@ -1470,7 +2172,7 @@ class TaskContextTools(ToolBase):
                 ],
                 "selection": {
                     "app_key": app_key,
-                    "record_id": record_id,
+                    "record_id": record_id_text,
                     "workflow_node_id": workflow_node_id,
                 },
                 "transport_error": {
@@ -1524,16 +2226,16 @@ class TaskContextTools(ToolBase):
             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,
-                )
+            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=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")
@@ -1555,7 +2257,7 @@ class TaskContextTools(ToolBase):
             "warnings": schema_warnings,
             "selection": {
                 "app_key": app_key,
-                "record_id": record_id,
+                "record_id": record_id_text,
                 "workflow_node_id": workflow_node_id,
             },
         }
@@ -1926,11 +2628,85 @@ class TaskContextTools(ToolBase):
         for item in items:
             if not isinstance(item, dict):
                 continue
-            if current_uid is not None and item.get("uid") == current_uid:
+            uid = _coerce_count(item.get("uid") or item.get("userId") or item.get("memberId") or item.get("id"))
+            if current_uid is not None and uid == current_uid:
                 continue
             filtered.append(item)
         return filtered
 
+    def _transfer_candidate_items(
+        self,
+        context: BackendRequestContext,
+        *,
+        app_key: str,
+        record_id: int,
+        workflow_node_id: int,
+        current_uid: int | None,
+    ) -> tuple[list[dict[str, Any]], list[JSONObject], JSONObject]:
+        page_size = 100
+        max_pages = 100
+        page_num = 1
+        fetched_pages = 0
+        fetched_raw_count = 0
+        page_amount: int | None = None
+        reported_total: int | None = None
+        items: list[dict[str, Any]] = []
+        seen_member_keys: set[str] = set()
+        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},
+            )
+            fetched_pages += 1
+            raw_items = _approval_page_items(result)
+            fetched_raw_count += len(raw_items)
+            if page_amount is None:
+                page_amount = _coerce_count(_approval_page_amount(result))
+            if reported_total is None:
+                reported_total = _coerce_count(_approval_page_total(result))
+            for item in self._filter_transfer_members(raw_items, current_uid=current_uid):
+                member_key = self._transfer_member_dedupe_key(item)
+                if member_key in seen_member_keys:
+                    continue
+                seen_member_keys.add(member_key)
+                items.append(item)
+            if not raw_items:
+                break
+            if page_amount is not None and page_num >= page_amount:
+                break
+            if reported_total is not None and fetched_raw_count >= reported_total:
+                break
+            page_num += 1
+        truncated = page_num > max_pages
+        if truncated:
+            warnings.append(
+                {
+                    "code": "TRANSFER_CANDIDATES_TRUNCATED",
+                    "message": "transfer candidates reached the MCP safety page cap; returned candidates may be incomplete.",
+                    "max_pages": max_pages,
+                    "page_size": page_size,
+                }
+            )
+        pagination: JSONObject = {
+            "loaded": True,
+            "page_size": page_size,
+            "fetched_pages": fetched_pages,
+            "reported_total": reported_total,
+            "page_amount": page_amount,
+            "truncated": truncated,
+        }
+        return items, warnings, pagination
+
+    def _transfer_member_dedupe_key(self, item: dict[str, Any]) -> str:
+        uid = item.get("uid") or item.get("userId") or item.get("memberId") or item.get("id")
+        if uid not in (None, ""):
+            return f"uid:{uid}"
+        return json.dumps(item, ensure_ascii=False, sort_keys=True, default=str)
+
     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 [])