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

package/src/qingflow_mcp/tools/record_tools.py

@@ -45,6 +45,11 @@ RECORD_ACCESS_UNBOUNDED_ROW_THRESHOLD = 50_000
 RECORD_ACCESS_TIME_BUDGET_SECONDS = 55.0
 RECORD_ACCESS_MIN_REMAINING_SECONDS = 8.0
 RECORD_GET_DETAIL_LOG_PAGE_SIZE = 10
+RECORD_LOGS_PAGE_SIZE = 200
+RECORD_LOGS_PREVIEW_LIMIT = 10
+RECORD_LOGS_MAX_ITEMS = 20_000
+RECORD_LOGS_TIME_BUDGET_SECONDS = 55.0
+RECORD_LOGS_MIN_REMAINING_SECONDS = 8.0
 RECORD_GET_MEDIA_MAX_IMAGES = 30
 RECORD_GET_MEDIA_MAX_IMAGE_BYTES = 20 * 1024 * 1024
 RECORD_GET_MEDIA_MAX_TOTAL_BYTES = 100 * 1024 * 1024
@@ -269,6 +274,30 @@ GENERIC_FIELD_ALIAS_OVERRIDES: dict[str, list[str]] = {
 FIELD_LOOKUP_STRIP_RE = re.compile(r"[\s_()（）\[\]【】{}<>·/\\:：-]+")
 
 
+def _pick_route_payload(payload: JSONObject) -> JSONObject:
+    return {
+        key: payload[key]
+        for key in (
+            "route_type",
+            "endpoint_kind",
+            "status",
+            "role",
+            "task_id",
+            "workflow_node_id",
+            "view_id",
+            "view_key",
+            "view_name",
+            "error_code",
+            "backend_code",
+            "http_status",
+            "request_id",
+            "message",
+            "reason",
+        )
+        if key in payload and payload[key] not in (None, "", [], {})
+    }
+
+
 class RecordTools(ToolBase):
     """记录工具（中文名：记录读写与分析）。
 
@@ -442,6 +471,20 @@ class RecordTools(ToolBase):
                 output_profile=output_profile,
             )
 
+        @mcp.tool(description="Read all visible data logs and workflow logs for one Qingflow record into local JSONL files. This tool hides pagination and returns file paths plus completeness metadata.")
+        def record_logs_get(
+            profile: str = DEFAULT_PROFILE,
+            app_key: str = "",
+            record_id: str = "",
+            view_id: str | None = None,
+        ) -> JSONObject:
+            return self.record_logs_get(
+                profile=profile,
+                app_key=app_key,
+                record_id=record_id,
+                view_id=view_id,
+            )
+
         @mcp.tool()
         def record_browse_schema_get(
             app_key: str = "",
@@ -493,8 +536,9 @@ class RecordTools(ToolBase):
         @mcp.tool(
             description=(
                 "Update one Qingflow record using a field map. "
-                "Use record_update_schema_get first. "
-                "This tool automatically probes accessible views in order and uses the first safe match."
+                "For simple field changes, call this tool directly after the target record is clear. "
+                "It first tries the data-manager direct route, then falls back to the frontend custom-view edit route when available. "
+                "Use record_update_schema_get for diagnostics or complex field-scope inspection."
             )
         )
         def record_update(
@@ -995,15 +1039,59 @@ class RecordTools(ToolBase):
                     item["title"]: self._ready_schema_template_value(item)
                     for item in writable_fields
                 },
+                "available_update_routes": self._record_update_schema_available_routes(matched_probes),
+                "recommended_update_route": {
+                    "route_type": "auto",
+                    "order": ["admin_direct", "view_edit", "task_save_only"],
+                    "message": "record_update will try data-manager direct edit first, then a matching custom-view edit route, then a unique current-user todo save-only route when the target fields are editable on that workflow node.",
+                },
             }
             if normalized_output_profile == "verbose":
                 response["view_probe_summary"] = probe_summary
                 response["record_context_probe"] = probe_summary
                 response["ambiguous_fields"] = ambiguous_fields
+                response["route_probe_summary"] = probe_summary
             return response
 
         return self._run_record_tool(profile, runner)
 
+    def _record_update_schema_available_routes(self, matched_probes: list[RecordContextRouteProbe]) -> list[JSONObject]:
+        routes: list[JSONObject] = [
+            {
+                "route_type": "admin_direct",
+                "endpoint_kind": "app_apply_update",
+                "role": 1,
+                "availability": "attempted_on_update",
+                "message": "Requires data-manager edit permission; record_update safely falls back if backend returns permission denied.",
+            }
+        ]
+        for probe in matched_probes:
+            if probe.route.kind != "custom":
+                continue
+            view_key = self._route_view_key(probe.route)
+            if not view_key:
+                continue
+            routes.append(
+                {
+                    "route_type": "view_edit",
+                    "endpoint_kind": "view_apply_update",
+                    "view_id": probe.route.view_id,
+                    "view_key": view_key,
+                    "view_name": probe.route.name,
+                    "availability": "candidate",
+                    "message": "Uses the same custom-view detail edit route as the frontend.",
+                }
+            )
+        routes.append(
+            {
+                "route_type": "task_save_only",
+                "endpoint_kind": "workflow_node_save_only",
+                "availability": "auto_probe_on_update",
+                "message": "record_update probes the current user's todo list and uses save-only only when exactly one matching task exists and the requested fields are editable on that workflow node.",
+            }
+        )
+        return routes
+
     def _record_update_schema_blocked_response(
         self,
         *,
@@ -2175,6 +2263,130 @@ class RecordTools(ToolBase):
 
         return self._run_record_tool(profile, runner)
 
+    @tool_cn_name("记录全量日志")
+    def record_logs_get(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: Any,
+        view_id: str | None = None,
+    ) -> JSONObject:
+        """读取单条记录可见的全量数据日志和流程日志，写入本地 JSONL。"""
+        record_id_int = normalize_positive_id_int(record_id, field_name="record_id")
+
+        def runner(session_profile, context):
+            resolved_view, compatibility_warnings = self._resolve_accessible_view_route(
+                profile,
+                context,
+                app_key,
+                view_id=view_id,
+                list_type=None,
+                view_key=None,
+                view_name=None,
+                allow_default=True,
+            )
+            warnings: list[JSONObject] = []
+            warnings.extend(compatibility_warnings)
+            warnings.extend(_view_filter_trust_warnings(resolved_view))
+            unavailable_context: list[JSONObject] = []
+
+            schema = self._record_get_detail_schema(profile, context, app_key, resolved_view, force_refresh=False)
+            index = _build_top_level_field_index(schema)
+            audit_info = self._record_get_audit_info(
+                context,
+                app_key=app_key,
+                record_id=record_id_int,
+                resolved_view=resolved_view,
+            )
+            audit_context = _record_detail_audit_context(audit_info, workflow_node_id=None)
+            detail_result, used_list_type, used_role = self._record_get_apply_detail(
+                context,
+                app_key=app_key,
+                record_id=record_id_int,
+                resolved_view=resolved_view,
+                audit_node_id=cast(int | None, audit_context.get("audit_node_id")),
+            )
+            answer_list = _record_detail_answers(detail_result)
+            selected_fields = list(index.by_id.values())
+            fields = [
+                _record_detail_field_payload(field, _find_answer_for_field(cast(list[JSONValue], answer_list), field), focus_id_set=set())
+                for field in selected_fields
+            ]
+            app_name = self._record_get_detail_app_name(
+                profile,
+                context,
+                app_key=app_key,
+                schema=schema,
+                used_list_type=used_list_type,
+            )
+            view_payload = _accessible_view_payload(resolved_view)
+            record_payload = _record_detail_record_payload(
+                app_key=app_key,
+                record_id=record_id_int,
+                detail=detail_result,
+                answer_list=cast(list[JSONValue], answer_list),
+                fields=fields,
+            )
+            log_visibility = self._record_get_log_visibility_context(
+                context,
+                app_key=app_key,
+                record_id=record_id_int,
+                resolved_view=resolved_view,
+                role=used_role,
+                audit_node_id=cast(int | None, audit_context.get("audit_node_id")),
+                unavailable_context=unavailable_context,
+            )
+            run_dir = _record_logs_run_dir()
+            run_dir.mkdir(parents=True, exist_ok=True)
+            deadline = time.monotonic() + RECORD_LOGS_TIME_BUDGET_SECONDS
+            data_logs = self._record_get_full_data_logs_context(
+                context,
+                app_key=app_key,
+                record_id=record_id_int,
+                role=used_role,
+                log_visibility=log_visibility,
+                unavailable_context=unavailable_context,
+                run_dir=run_dir,
+                deadline=deadline,
+            )
+            workflow_logs = self._record_get_full_workflow_logs_context(
+                context,
+                app_key=app_key,
+                record_id=record_id_int,
+                resolved_view=resolved_view,
+                role=used_role,
+                audit_node_id=cast(int | None, audit_context.get("audit_node_id")),
+                log_visibility=log_visibility,
+                unavailable_context=unavailable_context,
+                run_dir=run_dir,
+                deadline=deadline,
+            )
+            status = _record_logs_overall_status(data_logs=data_logs, workflow_logs=workflow_logs)
+            context_integrity = _record_logs_context_integrity(data_logs=data_logs, workflow_logs=workflow_logs)
+            payload: JSONObject = {
+                "ok": True,
+                "status": status,
+                "output_profile": "record_logs",
+                "app": {"app_key": app_key, "app_name": app_name},
+                "view": view_payload,
+                "record": record_payload,
+                "local_dir": str(run_dir),
+                "data_logs": data_logs,
+                "workflow_logs": workflow_logs,
+                "warnings": warnings,
+                "unavailable_context": unavailable_context,
+                "context_integrity": context_integrity,
+            }
+            summary_path = run_dir / "summary.json"
+            summary_payload = deepcopy(payload)
+            summary_payload.pop("request_route", None)
+            summary_path.write_text(json.dumps(summary_payload, ensure_ascii=False, indent=2), encoding="utf-8")
+            payload["summary_path"] = str(summary_path)
+            return payload
+
+        return self._run_record_tool(profile, runner)
+
     def _record_get_detail_context(
         self,
         *,
@@ -2824,6 +3036,108 @@ class RecordTools(ToolBase):
             unavailable_context.append(_record_detail_unavailable_context("workflow_logs", "流程日志本次获取失败。", exc))
             return _record_detail_log_unavailable_payload("workflow_logs", "fetch_unavailable")
 
+    def _record_get_full_data_logs_context(
+        self,
+        context,  # type: ignore[no-untyped-def]
+        *,
+        app_key: str,
+        record_id: int,
+        role: int,
+        log_visibility: JSONObject,
+        unavailable_context: list[JSONObject],
+        run_dir: Path,
+        deadline: float,
+    ) -> JSONObject:
+        """读取全量数据日志并写入 JSONL。"""
+        if log_visibility.get("status") == "unavailable":
+            return _record_logs_unavailable_payload("data_logs", "visibility_unavailable")
+        if log_visibility.get("data_log_visible") is False:
+            return _record_logs_hidden_payload("data_logs")
+
+        def fetch_page(page_num: int) -> JSONValue:
+            return self.backend.request(
+                "POST",
+                context,
+                f"/worksheet/data/log/{app_key}/{record_id}/page",
+                json_body={
+                    "viewChannel": log_visibility.get("channel"),
+                    "role": role,
+                    "pageNum": page_num,
+                    "pageSize": RECORD_LOGS_PAGE_SIZE,
+                },
+            )
+
+        try:
+            return _record_logs_fetch_all_to_jsonl(
+                fetch_page=fetch_page,
+                normalizer=_record_detail_data_log_item,
+                source="data_logs",
+                file_path=run_dir / "data-logs.jsonl",
+                deadline=deadline,
+            )
+        except QingflowApiError as exc:
+            unavailable_context.append(_record_detail_unavailable_context("data_logs", "全量数据日志获取失败。", exc))
+            return _record_logs_unavailable_payload("data_logs", "fetch_unavailable")
+
+    def _record_get_full_workflow_logs_context(
+        self,
+        context,  # type: ignore[no-untyped-def]
+        *,
+        app_key: str,
+        record_id: int,
+        resolved_view: AccessibleViewRoute,
+        role: int,
+        audit_node_id: int | None,
+        log_visibility: JSONObject,
+        unavailable_context: list[JSONObject],
+        run_dir: Path,
+        deadline: float,
+    ) -> JSONObject:
+        """读取全量流程日志并写入 JSONL。"""
+        if log_visibility.get("status") == "unavailable":
+            return _record_logs_unavailable_payload("workflow_logs", "visibility_unavailable")
+        if log_visibility.get("workflow_log_visible") is False:
+            return _record_logs_hidden_payload("workflow_logs")
+
+        def fetch_page(page_num: int) -> JSONValue:
+            if resolved_view.kind == "custom" and resolved_view.view_selection is not None:
+                return self.backend.request(
+                    "POST",
+                    context,
+                    f"/viewGraph/{resolved_view.view_selection.view_key}/workflow/node/record",
+                    json_body={
+                        "key": resolved_view.view_selection.view_key,
+                        "rowRecordId": str(record_id),
+                        "pageNum": page_num,
+                        "pageSize": RECORD_LOGS_PAGE_SIZE,
+                    },
+                )
+            return self.backend.request(
+                "POST",
+                context,
+                "/application/workflow/node/record",
+                json_body={
+                    "key": app_key,
+                    "rowRecordId": str(record_id),
+                    "nodeId": audit_node_id,
+                    "role": role,
+                    "pageNum": page_num,
+                    "pageSize": RECORD_LOGS_PAGE_SIZE,
+                },
+            )
+
+        try:
+            return _record_logs_fetch_all_to_jsonl(
+                fetch_page=fetch_page,
+                normalizer=_record_detail_workflow_log_item,
+                source="workflow_logs",
+                file_path=run_dir / "workflow-logs.jsonl",
+                deadline=deadline,
+            )
+        except QingflowApiError as exc:
+            unavailable_context.append(_record_detail_unavailable_context("workflow_logs", "全量流程日志获取失败。", exc))
+            return _record_logs_unavailable_payload("workflow_logs", "fetch_unavailable")
+
     def _record_get_associated_resources(
         self,
         context,  # type: ignore[no-untyped-def]
@@ -3530,71 +3844,720 @@ class RecordTools(ToolBase):
             output_profile=normalized_output_profile,
         )
 
-    def _record_update_public_single(
+    def _record_update_public_single(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int,
+        fields: JSONObject,
+        verify_write: bool,
+        output_profile: str,
+    ) -> JSONObject:
+        """执行内部辅助逻辑。"""
+        raw_preflight = self._preflight_record_update_with_auto_view(
+            profile=profile,
+            app_key=app_key,
+            record_id=record_id,
+            fields=fields,
+            force_refresh_form=False,
+        )
+        preflight_used_force_refresh = self._record_preflight_used_force_refresh(raw_preflight)
+        preflight_data = cast(JSONObject, raw_preflight.get("data", {}))
+        normalized_payload = self._record_write_normalized_payload(
+            operation="update",
+            record_id=record_id,
+            record_ids=[],
+            normalized_answers=cast(list[JSONObject], preflight_data.get("normalized_answers", [])),
+            submit_type=1,
+            selection=cast(JSONObject | None, preflight_data.get("selection") if isinstance(preflight_data.get("selection"), dict) else None),
+        )
+        if preflight_data.get("blockers"):
+            return self._record_write_blocked_response(
+                raw_preflight,
+                operation="update",
+                normalized_payload=normalized_payload,
+                output_profile=output_profile,
+                human_review=True,
+                target_resource={"type": "record", "app_key": app_key, "record_id": record_id, "record_ids": []},
+            )
+        route_apply, tried_routes, route_blocker = self._record_update_apply_with_auto_route(
+            profile=profile,
+            app_key=app_key,
+            record_id=record_id,
+            normalized_answers=cast(list[JSONObject], preflight_data.get("normalized_answers", [])),
+            preflight_data=preflight_data,
+            verify_write=verify_write,
+            force_refresh_form=preflight_used_force_refresh,
+        )
+        if route_blocker is not None:
+            return self._record_update_route_blocked_response(
+                raw_preflight=raw_preflight,
+                operation="update",
+                normalized_payload=normalized_payload,
+                output_profile=output_profile,
+                human_review=True,
+                app_key=app_key,
+                record_id=record_id,
+                tried_routes=tried_routes,
+                route_blocker=route_blocker,
+            )
+        raw_apply = cast(JSONObject, route_apply)
+        return self._record_write_apply_response(
+            raw_apply,
+            operation="update",
+            normalized_payload=normalized_payload,
+            output_profile=output_profile,
+            human_review=True,
+            preflight=raw_preflight,
+        )
+
+    def _record_update_apply_with_auto_route(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int,
+        normalized_answers: list[JSONObject],
+        preflight_data: JSONObject,
+        verify_write: bool,
+        force_refresh_form: bool,
+    ) -> tuple[JSONObject | None, list[JSONObject], JSONObject | None]:
+        """Try record update routes in the same order a frontend user would expect."""
+        tried_routes: list[JSONObject] = []
+        admin_attempt = self._record_update_route_attempt(
+            route_type="admin_direct",
+            endpoint_kind="app_apply_update",
+            role=1,
+            reason="try data-manager direct edit first",
+        )
+        try:
+            raw_apply = self.record_update(
+                profile=profile,
+                app_key=app_key,
+                apply_id=record_id,
+                answers=normalized_answers,
+                fields={},
+                role=1,
+                verify_write=verify_write,
+                force_refresh_form=force_refresh_form,
+            )
+            admin_attempt["status"] = "success"
+            raw_apply["update_route"] = self._record_update_route_public(admin_attempt)
+            raw_apply["tried_routes"] = [admin_attempt]
+            return raw_apply, [admin_attempt], None
+        except (QingflowApiError, RuntimeError) as exc:
+            api_error = self._record_update_extract_api_error(exc)
+            if api_error is None or not self._record_update_route_permission_denied(api_error):
+                raise
+            admin_attempt.update(self._record_update_route_error_payload(
+                api_error,
+                status="denied",
+                error_code="ADMIN_UPDATE_PERMISSION_DENIED",
+            ))
+            tried_routes.append(admin_attempt)
+
+        view_route = self._record_update_selected_custom_view_route(preflight_data)
+        if view_route is None:
+            tried_routes.append(
+                self._record_update_route_attempt(
+                    route_type="view_edit",
+                    endpoint_kind="view_apply_update",
+                    status="skipped",
+                    error_code="VIEW_UPDATE_ROUTE_NOT_AVAILABLE",
+                    reason="preflight did not select a single custom view route for this payload",
+                )
+            )
+        else:
+            view_attempt = self._record_update_route_attempt(
+                route_type="view_edit",
+                endpoint_kind="view_apply_update",
+                view_id=cast(str, view_route.get("view_id")),
+                view_key=cast(str, view_route.get("view_key")),
+                view_name=_normalize_optional_text(view_route.get("name")),
+                reason="fallback to frontend custom-view detail edit route",
+            )
+            try:
+                raw_apply = self._record_update_via_custom_view(
+                    profile=profile,
+                    app_key=app_key,
+                    apply_id=record_id,
+                    view_key=cast(str, view_route["view_key"]),
+                    answers=normalized_answers,
+                    verify_write=verify_write,
+                    force_refresh_form=force_refresh_form,
+                )
+                view_attempt["status"] = "success"
+                tried_routes.append(view_attempt)
+                raw_apply["update_route"] = self._record_update_route_public(view_attempt)
+                raw_apply["tried_routes"] = tried_routes
+                return raw_apply, tried_routes, None
+            except (QingflowApiError, RuntimeError) as exc:
+                api_error = self._record_update_extract_api_error(exc)
+                if api_error is None or not self._record_update_route_permission_denied(api_error):
+                    raise
+                view_attempt.update(self._record_update_route_error_payload(
+                    api_error,
+                    status="denied",
+                    error_code="VIEW_UPDATE_PERMISSION_DENIED",
+                ))
+                tried_routes.append(view_attempt)
+
+        task_route = self._record_update_task_save_only_candidate(
+            profile=profile,
+            app_key=app_key,
+            record_id=record_id,
+            normalized_answers=normalized_answers,
+        )
+        task_attempt = cast(JSONObject, task_route.get("attempt") if isinstance(task_route.get("attempt"), dict) else {})
+        if not task_route.get("available"):
+            tried_routes.append(task_attempt or self._record_update_route_attempt(
+                route_type="task_save_only",
+                endpoint_kind="workflow_node_save_only",
+                status="skipped",
+                error_code="TASK_UPDATE_ROUTE_NOT_AVAILABLE",
+                reason="no unique current-user todo task can edit the requested fields",
+            ))
+        else:
+            task_attempt = self._record_update_route_attempt(
+                route_type="task_save_only",
+                endpoint_kind="workflow_node_save_only",
+                role=3,
+                task_id=_normalize_optional_text(task_route.get("task_id")),
+                workflow_node_id=_coerce_count(task_route.get("workflow_node_id")),
+                reason="fallback to current-user workflow todo save-only route",
+            )
+            try:
+                raw_apply = self._record_update_via_task_save_only(
+                    profile=profile,
+                    app_key=app_key,
+                    apply_id=record_id,
+                    workflow_node_id=cast(int, task_route["workflow_node_id"]),
+                    answers=normalized_answers,
+                    verify_write=verify_write,
+                    force_refresh_form=force_refresh_form,
+                )
+                task_attempt["status"] = "success"
+                tried_routes.append(task_attempt)
+                raw_apply["update_route"] = self._record_update_route_public(task_attempt)
+                raw_apply["tried_routes"] = tried_routes
+                return raw_apply, tried_routes, None
+            except (QingflowApiError, RuntimeError) as exc:
+                api_error = self._record_update_extract_api_error(exc)
+                if api_error is None or not self._record_update_route_permission_denied(api_error):
+                    raise
+                task_attempt.update(self._record_update_route_error_payload(
+                    api_error,
+                    status="denied",
+                    error_code="TASK_UPDATE_PERMISSION_DENIED",
+                ))
+                tried_routes.append(task_attempt)
+        return None, tried_routes, {
+            "error_code": "NO_AVAILABLE_UPDATE_ROUTE",
+            "message": "No available record update route could execute this payload for the current user.",
+            "recommended_next_actions": [
+                "If this user should edit the record as a data manager, grant data edit permission and retry record_update.",
+                "If the record is editable from a specific table view in the UI, make sure the target fields are visible and editable in that view.",
+                "If this is workflow work, use task_list -> task_get -> task_action_execute(action='save_only') with the current task context.",
+            ],
+        }
+
+    def _record_update_selected_custom_view_route(self, preflight_data: JSONObject) -> JSONObject | None:
+        selection = preflight_data.get("selection")
+        if not isinstance(selection, dict):
+            return None
+        view = selection.get("view")
+        if not isinstance(view, dict):
+            return None
+        view_id = _normalize_optional_text(view.get("view_id"))
+        if not view_id or not view_id.startswith("custom:"):
+            return None
+        view_key = _normalize_optional_text(view.get("view_key")) or view_id.split(":", 1)[1].strip()
+        if not view_key:
+            return None
+        return {
+            "view_id": view_id,
+            "view_key": view_key,
+            "name": view.get("name"),
+        }
+
+    def _record_update_route_attempt(
+        self,
+        *,
+        route_type: str,
+        endpoint_kind: str,
+        status: str = "attempted",
+        role: int | None = None,
+        task_id: str | None = None,
+        workflow_node_id: int | None = None,
+        view_id: str | None = None,
+        view_key: str | None = None,
+        view_name: str | None = None,
+        error_code: str | None = None,
+        reason: str | None = None,
+    ) -> JSONObject:
+        payload: JSONObject = {
+            "route_type": route_type,
+            "endpoint_kind": endpoint_kind,
+            "status": status,
+        }
+        if role is not None:
+            payload["role"] = role
+        if task_id:
+            payload["task_id"] = task_id
+        if workflow_node_id is not None:
+            payload["workflow_node_id"] = workflow_node_id
+        if view_id:
+            payload["view_id"] = view_id
+        if view_key:
+            payload["view_key"] = view_key
+        if view_name:
+            payload["view_name"] = view_name
+        if error_code:
+            payload["error_code"] = error_code
+        if reason:
+            payload["reason"] = reason
+        return payload
+
+    def _record_update_route_public(self, attempt: JSONObject) -> JSONObject:
+        return _pick_route_payload(attempt)
+
+    def _record_update_route_error_payload(
+        self,
+        exc: QingflowApiError,
+        *,
+        status: str,
+        error_code: str,
+    ) -> JSONObject:
+        payload: JSONObject = {
+            "status": status,
+            "error_code": error_code,
+            "message": exc.message,
+        }
+        if exc.backend_code is not None:
+            payload["backend_code"] = exc.backend_code
+        if exc.http_status is not None:
+            payload["http_status"] = exc.http_status
+        if exc.request_id is not None:
+            payload["request_id"] = exc.request_id
+        return payload
+
+    def _record_update_extract_api_error(self, exc: QingflowApiError | RuntimeError) -> QingflowApiError | None:
+        if isinstance(exc, QingflowApiError):
+            return exc
+        try:
+            payload = json.loads(str(exc))
+        except json.JSONDecodeError:
+            return None
+        if not isinstance(payload, dict):
+            return None
+        return QingflowApiError(
+            category=str(payload.get("category") or "backend"),
+            message=str(payload.get("message") or exc),
+            backend_code=payload.get("backend_code"),
+            request_id=_normalize_optional_text(payload.get("request_id")),
+            http_status=_coerce_count(payload.get("http_status")),
+            details=cast(JSONObject | None, payload.get("details") if isinstance(payload.get("details"), dict) else None),
+        )
+
+    def _record_update_route_permission_denied(self, exc: QingflowApiError) -> bool:
+        if exc.backend_code in {40002, 40027, 40038, 404}:
+            return True
+        if exc.http_status == 404:
+            return True
+        return False
+
+    def _record_update_route_blocked_response(
+        self,
+        *,
+        raw_preflight: JSONObject,
+        operation: str,
+        normalized_payload: JSONObject,
+        output_profile: str,
+        human_review: bool,
+        app_key: str,
+        record_id: int,
+        tried_routes: list[JSONObject],
+        route_blocker: JSONObject,
+    ) -> JSONObject:
+        plan_data = cast(JSONObject, raw_preflight.get("data", {}))
+        validation = cast(JSONObject, plan_data.get("validation", {}))
+        warnings_payload = validation.get("warnings", [])
+        warnings = [{"code": "PREFLIGHT_WARNING", "message": str(item)} for item in warnings_payload] if isinstance(warnings_payload, list) else []
+        warnings.append(
+            {
+                "code": cast(str, route_blocker.get("error_code") or "NO_AVAILABLE_UPDATE_ROUTE"),
+                "message": cast(str, route_blocker.get("message") or "No update route could execute the write."),
+            }
+        )
+        recommended = list(route_blocker.get("recommended_next_actions") or [])
+        response: JSONObject = {
+            "profile": raw_preflight.get("profile"),
+            "ws_id": raw_preflight.get("ws_id"),
+            "ok": False,
+            "status": "blocked",
+            "write_executed": False,
+            "verification_status": "not_requested",
+            "safe_to_retry": True,
+            "request_route": raw_preflight.get("request_route"),
+            "warnings": warnings,
+            "output_profile": output_profile,
+            "update_route": None,
+            "tried_routes": tried_routes,
+            "error_code": route_blocker.get("error_code"),
+            "data": {
+                "action": {"operation": operation, "executed": False},
+                "resource": {"type": "record", "app_key": app_key, "record_id": stringify_backend_id(record_id), "record_ids": []},
+                "verification": None,
+                "normalized_payload": normalized_payload,
+                "blockers": [route_blocker.get("error_code") or "NO_AVAILABLE_UPDATE_ROUTE"],
+                "field_errors": [],
+                "confirmation_requests": [],
+                "resolved_fields": cast(list[JSONObject], plan_data.get("lookup_resolved_fields", [])),
+                "recommended_next_actions": recommended,
+                "human_review": self._record_write_human_review_payload(operation, enabled=human_review),
+                "error": route_blocker,
+                "update_route": None,
+                "tried_routes": tried_routes,
+            },
+        }
+        if output_profile == "verbose":
+            response["data"]["debug"] = {"preflight": plan_data}
+        return response
+
+    def _record_update_task_save_only_candidate(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        record_id: int,
+        normalized_answers: list[JSONObject],
+    ) -> JSONObject:
+        requested_question_ids = self._record_update_answer_question_ids(normalized_answers)
+
+        def unavailable(*, status: str = "skipped", error_code: str, reason: str, extra: JSONObject | None = None) -> JSONObject:
+            attempt = self._record_update_route_attempt(
+                route_type="task_save_only",
+                endpoint_kind="workflow_node_save_only",
+                status=status,
+                error_code=error_code,
+                reason=reason,
+            )
+            if extra:
+                attempt.update(extra)
+            return {"available": False, "attempt": attempt}
+
+        def runner(session_profile, context):
+            matches: list[JSONObject] = []
+            pages_scanned = 0
+            for page_num in range(1, VERIFY_TASK_FALLBACK_MAX_PAGES + 1):
+                try:
+                    task_page = self.backend.request(
+                        "POST",
+                        context,
+                        "/task/dynamic/page",
+                        json_body={
+                            "type": 1,
+                            "processStatus": 1,
+                            "appKey": app_key,
+                            "pageNum": page_num,
+                            "pageSize": VERIFY_TASK_FALLBACK_PAGE_SIZE,
+                        },
+                    )
+                except QingflowApiError as exc:
+                    return unavailable(
+                        error_code="TASK_UPDATE_ROUTE_NOT_AVAILABLE",
+                        reason="current-user todo task list is unavailable",
+                        extra=self._record_update_route_error_payload(
+                            exc,
+                            status="skipped",
+                            error_code="TASK_UPDATE_ROUTE_NOT_AVAILABLE",
+                        ),
+                    )
+                pages_scanned += 1
+                rows = task_page.get("list") if isinstance(task_page, dict) else None
+                items = [item for item in rows if isinstance(item, dict)] if isinstance(rows, list) else []
+                for item in items:
+                    candidate_record_id = _coerce_count(item.get("rowRecordId") or item.get("recordId") or item.get("applyId"))
+                    if candidate_record_id == record_id:
+                        matches.append(dict(item))
+                if not _page_has_more(cast(JSONObject, task_page if isinstance(task_page, dict) else {}), page_num, VERIFY_TASK_FALLBACK_PAGE_SIZE, len(items)):
+                    break
+
+            if not matches:
+                return unavailable(
+                    error_code="TASK_UPDATE_ROUTE_NOT_AVAILABLE",
+                    reason="no current-user todo task was found for this record",
+                    extra={"pages_scanned": pages_scanned},
+                )
+            if len(matches) > 1:
+                return unavailable(
+                    error_code="TASK_UPDATE_ROUTE_AMBIGUOUS",
+                    reason="multiple current-user todo tasks match this record; refusing to guess workflow context",
+                    extra={"matched_tasks": [self._record_update_compact_task_match(item) for item in matches[:5]]},
+                )
+
+            task = matches[0]
+            workflow_node_id = _coerce_count(task.get("nodeId") or task.get("auditNodeId"))
+            if workflow_node_id is None:
+                return unavailable(
+                    error_code="TASK_UPDATE_ROUTE_NOT_AVAILABLE",
+                    reason="matched todo task does not expose a workflow node id",
+                    extra={"matched_task": self._record_update_compact_task_match(task)},
+                )
+            try:
+                editable_payload = self.backend.request(
+                    "GET",
+                    context,
+                    f"/app/{app_key}/auditNode/{workflow_node_id}/editableQueIds",
+                )
+            except QingflowApiError as exc:
+                return unavailable(
+                    error_code="TASK_EDITABLE_FIELDS_UNAVAILABLE",
+                    reason="workflow node editable field list is unavailable; record_update will not guess task editability",
+                    extra=self._record_update_route_error_payload(
+                        exc,
+                        status="skipped",
+                        error_code="TASK_EDITABLE_FIELDS_UNAVAILABLE",
+                    ),
+                )
+            editable_question_ids = self._record_update_extract_question_ids(editable_payload)
+            if not editable_question_ids:
+                return unavailable(
+                    error_code="TASK_UPDATE_ROUTE_NOT_AVAILABLE",
+                    reason="workflow node editable field list is empty",
+                    extra={
+                        "task_id": stringify_backend_id(task.get("id") or task.get("taskId")),
+                        "workflow_node_id": workflow_node_id,
+                    },
+                )
+            effective_editable_question_ids = self._record_update_effective_task_editable_ids(
+                editable_question_ids,
+                normalized_answers=normalized_answers,
+            )
+            non_editable = sorted(
+                question_id for question_id in requested_question_ids
+                if question_id not in effective_editable_question_ids
+            )
+            if non_editable:
+                return unavailable(
+                    status="denied",
+                    error_code="TASK_UPDATE_FIELD_NOT_EDITABLE",
+                    reason="one or more requested fields are not editable on the current workflow node",
+                    extra={
+                        "task_id": stringify_backend_id(task.get("id") or task.get("taskId")),
+                        "workflow_node_id": workflow_node_id,
+                        "non_editable_question_ids": non_editable,
+                    },
+                )
+            return {
+                "available": True,
+                "task_id": stringify_backend_id(task.get("id") or task.get("taskId")),
+                "workflow_node_id": workflow_node_id,
+                "matched_task": self._record_update_compact_task_match(task),
+                "editable_question_ids": sorted(editable_question_ids),
+                "effective_editable_question_ids": sorted(effective_editable_question_ids),
+            }
+
+        return self._run_record_tool(profile, runner)
+
+    def _record_update_compact_task_match(self, item: JSONObject) -> JSONObject:
+        return {
+            key: value
+            for key, value in {
+                "task_id": stringify_backend_id(item.get("id") or item.get("taskId")),
+                "record_id": stringify_backend_id(item.get("rowRecordId") or item.get("recordId") or item.get("applyId")),
+                "workflow_node_id": item.get("nodeId") or item.get("auditNodeId"),
+                "workflow_node_name": item.get("nodeName") or item.get("auditNodeName"),
+            }.items()
+            if value not in (None, "", [], {})
+        }
+
+    def _record_update_answer_question_ids(self, answers: list[JSONObject]) -> set[int]:
+        question_ids: set[int] = set()
+        for answer in answers:
+            if not isinstance(answer, dict):
+                continue
+            que_id = _coerce_count(answer.get("queId"))
+            if que_id is not None and que_id > 0:
+                question_ids.add(que_id)
+            table_values = answer.get("tableValues")
+            if not isinstance(table_values, list):
+                continue
+            for row in table_values:
+                if not isinstance(row, list):
+                    continue
+                for cell in row:
+                    if not isinstance(cell, dict):
+                        continue
+                    cell_que_id = _coerce_count(cell.get("queId"))
+                    if cell_que_id is not None and cell_que_id > 0:
+                        question_ids.add(cell_que_id)
+        return question_ids
+
+    def _record_update_extract_question_ids(self, payload: JSONValue) -> set[int]:
+        candidates: list[Any] = []
+        if isinstance(payload, list):
+            candidates = payload
+        elif isinstance(payload, dict):
+            for key in ("editableQueIds", "editableQuestionIds", "queIds", "questionIds", "ids", "list", "result"):
+                value = payload.get(key)
+                if isinstance(value, list):
+                    candidates = value
+                    break
+        question_ids: set[int] = set()
+        for item in candidates:
+            value: Any = item
+            if isinstance(item, dict):
+                value = item.get("queId", item.get("questionId", item.get("id")))
+            que_id = _coerce_count(value)
+            if que_id is not None and que_id > 0:
+                question_ids.add(que_id)
+        return question_ids
+
+    def _record_update_effective_task_editable_ids(
+        self,
+        editable_question_ids: set[int],
+        *,
+        normalized_answers: list[JSONObject],
+    ) -> set[int]:
+        effective_editable_ids = set(editable_question_ids)
+        for answer in normalized_answers:
+            if not isinstance(answer, dict):
+                continue
+            parent_que_id = _coerce_count(answer.get("queId"))
+            if parent_que_id is None or parent_que_id <= 0:
+                continue
+            table_values = answer.get("tableValues")
+            if not isinstance(table_values, list) or not table_values:
+                continue
+            row_subfield_ids: set[int] = set()
+            for row in table_values:
+                if not isinstance(row, list):
+                    continue
+                for cell in row:
+                    if not isinstance(cell, dict):
+                        continue
+                    cell_que_id = _coerce_count(cell.get("queId"))
+                    if cell_que_id is not None and cell_que_id > 0:
+                        row_subfield_ids.add(cell_que_id)
+            if row_subfield_ids & editable_question_ids:
+                effective_editable_ids.add(parent_que_id)
+        return effective_editable_ids
+
+    def _record_update_via_custom_view(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        apply_id: int,
+        view_key: str,
+        answers: list[JSONObject],
+        verify_write: bool,
+        force_refresh_form: bool,
+    ) -> JSONObject:
+        normalized_apply_id = self._validate_app_and_record(app_key, apply_id)
+        normalized_view_key = view_key.strip()
+        if not normalized_view_key:
+            raise_tool_error(QingflowApiError.config_error("view_key is required for custom view update"))
+
+        def runner(session_profile, context):
+            index = self._get_field_index(profile, context, app_key, force_refresh=force_refresh_form) if verify_write else None
+            normalized_answers = [dict(item) for item in answers if isinstance(item, dict)]
+            self._validate_record_write(app_key, normalized_answers, apply_id=normalized_apply_id)
+            result = self.backend.request(
+                "POST",
+                context,
+                f"/view/{normalized_view_key}/apply/{normalized_apply_id}",
+                json_body={"answers": normalized_answers},
+            )
+            verification = self._verify_record_write_result(
+                context,
+                app_key=app_key,
+                apply_id=normalized_apply_id,
+                normalized_answers=normalized_answers,
+                index=cast(FieldIndex, index),
+                verify_view_key=normalized_view_key,
+            ) if verify_write and index is not None else None
+            verified = True if verification is None else bool(verification.get("verified"))
+            return self._attach_human_review_notice(
+                {
+                    "profile": profile,
+                    "ws_id": session_profile.selected_ws_id,
+                    "request_route": self._request_route_payload(context),
+                    "app_key": app_key,
+                    "apply_id": normalized_apply_id,
+                    "record_id": normalized_apply_id,
+                    "result": result,
+                    "normalized_answers": normalized_answers,
+                    "status": "completed" if verified else "verification_failed",
+                    "ok": True,
+                    "verify_write": verify_write,
+                    "write_verified": verified if verify_write else None,
+                    "verification": verification,
+                    "resource": _record_resource_payload(normalized_apply_id),
+                },
+                operation="update",
+                target="record data",
+            )
+
+        return self._run_record_tool(profile, runner)
+
+    def _record_update_via_task_save_only(
         self,
         *,
         profile: str,
         app_key: str,
-        record_id: int,
-        fields: JSONObject,
+        apply_id: int,
+        workflow_node_id: int,
+        answers: list[JSONObject],
         verify_write: bool,
-        output_profile: str,
+        force_refresh_form: bool,
     ) -> JSONObject:
-        """执行内部辅助逻辑。"""
-        raw_preflight = self._preflight_record_update_with_auto_view(
-            profile=profile,
-            app_key=app_key,
-            record_id=record_id,
-            fields=fields,
-            force_refresh_form=False,
-        )
-        preflight_used_force_refresh = self._record_preflight_used_force_refresh(raw_preflight)
-        preflight_data = cast(JSONObject, raw_preflight.get("data", {}))
-        normalized_payload = self._record_write_normalized_payload(
-            operation="update",
-            record_id=record_id,
-            record_ids=[],
-            normalized_answers=cast(list[JSONObject], preflight_data.get("normalized_answers", [])),
-            submit_type=1,
-            selection=cast(JSONObject | None, preflight_data.get("selection") if isinstance(preflight_data.get("selection"), dict) else None),
-        )
-        if preflight_data.get("blockers"):
-            return self._record_write_blocked_response(
-                raw_preflight,
-                operation="update",
-                normalized_payload=normalized_payload,
-                output_profile=output_profile,
-                human_review=True,
-                target_resource={"type": "record", "app_key": app_key, "record_id": record_id, "record_ids": []},
+        normalized_apply_id = self._validate_app_and_record(app_key, apply_id)
+        if workflow_node_id <= 0:
+            raise_tool_error(QingflowApiError.config_error("workflow_node_id must be positive for task save-only update"))
+
+        def runner(session_profile, context):
+            index = self._get_field_index(profile, context, app_key, force_refresh=force_refresh_form) if verify_write else None
+            normalized_answers = [dict(item) for item in answers if isinstance(item, dict)]
+            self._validate_record_write(app_key, normalized_answers, apply_id=normalized_apply_id)
+            result = self.backend.request(
+                "POST",
+                context,
+                f"/app/{app_key}/apply/{normalized_apply_id}",
+                json_body={"role": 3, "auditNodeId": workflow_node_id, "answers": normalized_answers},
             )
-        try:
-            raw_apply = self.record_update(
-                profile=profile,
+            verification = self._verify_record_write_result(
+                context,
                 app_key=app_key,
-                apply_id=record_id,
-                answers=cast(list[JSONObject], preflight_data.get("normalized_answers", [])),
-                fields={},
-                role=1,
-                verify_write=verify_write,
-                force_refresh_form=preflight_used_force_refresh,
-            )
-        except QingflowApiError as exc:
-            self._raise_record_write_permission_error(
-                exc,
+                apply_id=normalized_apply_id,
+                normalized_answers=normalized_answers,
+                index=cast(FieldIndex, index),
+            ) if verify_write and index is not None else None
+            verified = True if verification is None else bool(verification.get("verified"))
+            return self._attach_human_review_notice(
+                {
+                    "profile": profile,
+                    "ws_id": session_profile.selected_ws_id,
+                    "request_route": self._request_route_payload(context),
+                    "app_key": app_key,
+                    "apply_id": normalized_apply_id,
+                    "record_id": normalized_apply_id,
+                    "result": result,
+                    "normalized_answers": normalized_answers,
+                    "status": "completed" if verified else "verification_failed",
+                    "ok": True,
+                    "verify_write": verify_write,
+                    "write_verified": verified if verify_write else None,
+                    "verification": verification,
+                    "resource": _record_resource_payload(normalized_apply_id),
+                },
                 operation="update",
-                app_key=app_key,
-                record_id=record_id,
-                selection=cast(JSONObject | None, preflight_data.get("selection") if isinstance(preflight_data.get("selection"), dict) else None),
+                target="record data",
             )
-            raise
-        return self._record_write_apply_response(
-            raw_apply,
-            operation="update",
-            normalized_payload=normalized_payload,
-            output_profile=output_profile,
-            human_review=True,
-            preflight=raw_preflight,
-        )
+
+        return self._run_record_tool(profile, runner)
 
     def _record_update_public_batch(
         self,
@@ -3757,13 +4720,44 @@ class RecordTools(ToolBase):
         """执行内部辅助逻辑。"""
         summary = self._record_update_batch_summary(responses)
         batch_items = [self._record_update_batch_item_from_response(response, output_profile=output_profile) for response in responses]
+        public_items = [self._record_update_public_batch_item(item, index=index) for index, item in enumerate(batch_items)]
         status, ok, message = self._record_update_batch_envelope_status(summary=summary, dry_run=dry_run)
         first_response = responses[0] if responses else {}
+        applied_count = int(summary.get("applied_count") or 0)
+        ready_count = int(summary.get("ready_count") or 0)
+        verified_count = int(summary.get("verified_count") or 0)
+        field_level_verified_count = int(summary.get("field_level_verified_count") or 0)
+        confirmation_count = int(summary.get("confirmation_count") or 0)
+        blocked_count = int(summary.get("blocked_count") or 0)
+        failed_count = int(summary.get("failed_count") or 0)
+        write_executed = applied_count > 0
+        verification_status = "not_requested"
+        if write_executed:
+            verification_status = "verified" if verified_count == applied_count else "failed"
+        updated_record_ids = [
+            str(item.get("record_id"))
+            for item in public_items
+            if item.get("record_id") not in (None, "") and str(item.get("status") or "").lower() == "success"
+        ]
         return {
             "profile": first_response.get("profile", profile),
             "ws_id": first_response.get("ws_id"),
             "ok": ok,
             "status": status,
+            "mode": "batch",
+            "dry_run": dry_run,
+            "app_key": app_key,
+            "total": int(summary.get("total") or 0),
+            "succeeded": ready_count if dry_run else applied_count,
+            "failed": blocked_count + failed_count,
+            "needs_confirmation": confirmation_count,
+            "updated_record_ids": updated_record_ids,
+            "write_executed": write_executed,
+            "safe_to_retry": not write_executed,
+            "verification_status": verification_status,
+            "field_level_verified_count": field_level_verified_count,
+            "summary": summary,
+            "items": public_items,
             "request_route": first_response.get("request_route"),
             "warnings": [],
             "output_profile": output_profile,
@@ -3777,6 +4771,31 @@ class RecordTools(ToolBase):
             "message": message,
         }
 
+    def _record_update_public_batch_item(self, item: JSONObject, *, index: int) -> JSONObject:
+        """执行内部辅助逻辑。"""
+        public = dict(item)
+        public.setdefault("index", index)
+        public.setdefault("row_number", index + 1)
+        resource = public.get("resource")
+        if isinstance(resource, dict):
+            record_id = resource.get("record_id")
+            apply_id = resource.get("apply_id")
+            if record_id not in (None, ""):
+                public["record_id"] = str(record_id)
+            if apply_id not in (None, ""):
+                public["apply_id"] = str(apply_id)
+        status = str(public.get("status") or "").lower()
+        verification = public.get("verification")
+        if isinstance(verification, dict):
+            if bool(verification.get("verified")):
+                public.setdefault("verification_status", "verified")
+            elif status == "success":
+                public.setdefault("verification_status", "failed")
+        public.setdefault("write_executed", status == "success")
+        public.setdefault("safe_to_retry", not bool(public.get("write_executed")))
+        public.setdefault("verification_status", "not_requested")
+        return public
+
     def _record_update_batch_summary(self, responses: list[JSONObject]) -> JSONObject:
         """执行内部辅助逻辑。"""
         summary: JSONObject = {
@@ -3837,6 +4856,12 @@ class RecordTools(ToolBase):
             "confirmation_requests": cast(list[JSONObject], data.get("confirmation_requests", [])),
             "resolved_fields": cast(list[JSONObject], data.get("resolved_fields", [])),
         }
+        update_route = response.get("update_route")
+        if isinstance(update_route, dict):
+            item["update_route"] = update_route
+        tried_routes = response.get("tried_routes")
+        if isinstance(tried_routes, list):
+            item["tried_routes"] = tried_routes
         blockers = data.get("blockers")
         if isinstance(blockers, list) and blockers:
             item["blockers"] = blockers
@@ -4702,6 +5727,11 @@ class RecordTools(ToolBase):
             delete_ids = [normalize_positive_id_int(record_id, field_name="record_id")]
         if not delete_ids:
             raise_tool_error(QingflowApiError.config_error("record_id or record_ids is required"))
+        seen_delete_ids: set[int] = set()
+        for item in delete_ids:
+            if item in seen_delete_ids:
+                raise_tool_error(QingflowApiError.config_error(f"duplicate record id in delete payload: {stringify_backend_id(item)}"))
+            seen_delete_ids.add(item)
         normalized_payload = {
             "operation": "delete",
             "record_id": stringify_backend_id(record_id) if record_id is not None else None,
@@ -4709,16 +5739,134 @@ class RecordTools(ToolBase):
             "answers": [],
             "submit_type": 1,
         }
-        raw_apply = self._record_delete_many(profile=profile, app_key=app_key, record_ids=delete_ids)
-        return self._record_write_apply_response(
-            raw_apply,
-            operation="delete",
+        return self._record_delete_public_batch(
+            profile=profile,
+            app_key=app_key,
+            delete_ids=delete_ids,
             normalized_payload=normalized_payload,
             output_profile=normalized_output_profile,
-            human_review=True,
-            preflight=None,
         )
 
+    def _record_delete_public_batch(
+        self,
+        *,
+        profile: str,
+        app_key: str,
+        delete_ids: list[int],
+        normalized_payload: JSONObject,
+        output_profile: str,
+    ) -> JSONObject:
+        items: list[JSONObject] = []
+        request_route: JSONObject | None = None
+        ws_id: object = None
+        for index, delete_id in enumerate(delete_ids):
+            record_id_text = stringify_backend_id(delete_id)
+            try:
+                raw_apply = self._record_delete_many(profile=profile, app_key=app_key, record_ids=[delete_id])
+                request_route = cast(JSONObject, raw_apply.get("request_route")) if isinstance(raw_apply.get("request_route"), dict) else request_route
+                ws_id = raw_apply.get("ws_id", ws_id)
+                single_payload = {
+                    "operation": "delete",
+                    "record_id": record_id_text,
+                    "record_ids": [record_id_text],
+                    "answers": [],
+                    "submit_type": 1,
+                }
+                single_response = self._record_write_apply_response(
+                    raw_apply,
+                    operation="delete",
+                    normalized_payload=single_payload,
+                    output_profile=output_profile,
+                    human_review=True,
+                    preflight=None,
+                )
+                item_status = str(single_response.get("status") or "success")
+                item: JSONObject = {
+                    "index": index,
+                    "row_number": index + 1,
+                    "record_id": record_id_text,
+                    "status": item_status,
+                    "write_executed": bool(single_response.get("write_executed")),
+                    "verification_status": single_response.get("verification_status", "not_requested"),
+                    "safe_to_retry": bool(single_response.get("safe_to_retry", False)),
+                }
+                if item_status != "success":
+                    item["error"] = (single_response.get("data") or {}).get("error") if isinstance(single_response.get("data"), dict) else None
+                items.append(item)
+            except (QingflowApiError, RuntimeError) as exc:
+                error_response = self._record_write_exception_response(
+                    exc,
+                    operation="delete",
+                    profile=profile,
+                    app_key=app_key,
+                    record_id=record_id_text,
+                    output_profile=output_profile,
+                    human_review=True,
+                    write_executed=False,
+                )
+                request_route = cast(JSONObject, error_response.get("request_route")) if isinstance(error_response.get("request_route"), dict) else request_route
+                item = {
+                    "index": index,
+                    "row_number": index + 1,
+                    "record_id": record_id_text,
+                    "status": "failed",
+                    "write_executed": False,
+                    "verification_status": "not_requested",
+                    "safe_to_retry": True,
+                    "error": (error_response.get("data") or {}).get("error") if isinstance(error_response.get("data"), dict) else {"message": str(exc)},
+                }
+                items.append(item)
+        deleted_ids = [
+            str(item["record_id"])
+            for item in items
+            if str(item.get("status") or "") == "success"
+        ]
+        failed_ids = [
+            str(item["record_id"])
+            for item in items
+            if str(item.get("status") or "") != "success"
+        ]
+        total = len(items)
+        succeeded = len(deleted_ids)
+        failed = len(failed_ids)
+        if succeeded and failed:
+            status = "partial_success"
+            ok = False
+        elif succeeded:
+            status = "success"
+            ok = True
+        else:
+            status = "failed"
+            ok = False
+        write_executed = any(bool(item.get("write_executed")) for item in items)
+        return {
+            "profile": profile,
+            "ws_id": ws_id,
+            "ok": ok,
+            "status": status,
+            "mode": "batch",
+            "total": total,
+            "succeeded": succeeded,
+            "failed": failed,
+            "deleted_ids": deleted_ids,
+            "failed_ids": failed_ids,
+            "write_executed": write_executed,
+            "verification_status": "not_requested",
+            "safe_to_retry": False if write_executed else True,
+            "request_route": request_route,
+            "warnings": [],
+            "output_profile": output_profile,
+            "items": items,
+            "data": {
+                "action": {"operation": "delete", "executed": write_executed},
+                "resource": {"type": "record", "app_key": app_key, "record_id": None, "record_ids": [stringify_backend_id(item) for item in delete_ids]},
+                "normalized_payload": normalized_payload,
+                "deleted_ids": deleted_ids,
+                "failed_ids": failed_ids,
+                "items": items,
+            },
+        }
+
     @tool_cn_name("写入记录")
     def record_write(
         self,
@@ -7277,6 +8425,7 @@ class RecordTools(ToolBase):
                 field_index_override=index,
             )
         except RecordInputError as error:
+            normalized_answers = list(lookup_resolution.normalized_answers)
             invalid_fields.append(
                 {
                     "location": _stringify_json(error.details.get("location") if error.details else None),
@@ -10632,6 +11781,8 @@ class RecordTools(ToolBase):
         response_status = "verification_failed" if verification_status == "failed" else "success"
         if not bool(raw_apply.get("ok", True)) and verification_status != "failed":
             response_status = raw_status or "failed"
+        update_route = raw_apply.get("update_route") if isinstance(raw_apply.get("update_route"), dict) else None
+        tried_routes = raw_apply.get("tried_routes") if isinstance(raw_apply.get("tried_routes"), list) else []
         response: JSONObject = {
             "profile": raw_apply.get("profile"),
             "ws_id": raw_apply.get("ws_id"),
@@ -10643,6 +11794,8 @@ class RecordTools(ToolBase):
             "request_route": raw_apply.get("request_route"),
             "warnings": warnings,
             "output_profile": output_profile,
+            "update_route": update_route,
+            "tried_routes": tried_routes,
             "data": {
                 "action": {"operation": operation, "executed": True},
                 "resource": resource,
@@ -10653,6 +11806,8 @@ class RecordTools(ToolBase):
                 "confirmation_requests": [],
                 "resolved_fields": resolved_fields,
                 "human_review": self._record_write_human_review_payload(operation, enabled=human_review),
+                "update_route": update_route,
+                "tried_routes": tried_routes,
             },
         }
         if record_id is not None:
@@ -12224,6 +13379,7 @@ class RecordTools(ToolBase):
         normalized_answers: list[JSONObject],
         index: FieldIndex,
         verify_list_type: int = DEFAULT_RECORD_LIST_TYPE,
+        verify_view_key: str | None = None,
     ) -> JSONObject:
         """执行内部辅助逻辑。"""
         if apply_id is None:
@@ -12235,13 +13391,36 @@ class RecordTools(ToolBase):
                 "count_mismatches": [],
             }
         try:
-            record = self.backend.request(
-                "GET",
-                context,
-                f"/app/{app_key}/apply/{apply_id}",
-                params={"role": 1, "listType": verify_list_type},
-            )
+            if verify_view_key:
+                record = self.backend.request(
+                    "GET",
+                    context,
+                    f"/view/{verify_view_key}/apply/{apply_id}",
+                )
+            else:
+                record = self.backend.request(
+                    "GET",
+                    context,
+                    f"/app/{app_key}/apply/{apply_id}",
+                    params={"role": 1, "listType": verify_list_type},
+                )
         except QingflowApiError as exc:
+            if verify_view_key:
+                return {
+                    "verified": False,
+                    "verification_mode": "custom_view_record_detail",
+                    "field_level_verified": False,
+                    "error": "custom_view_readback_failed",
+                    "missing_fields": [],
+                    "empty_fields": [],
+                    "count_mismatches": [],
+                    "warnings": [{
+                        "code": "WRITE_VERIFY_CUSTOM_VIEW_READBACK_FAILED",
+                        "message": "Write was sent through a custom view route, but the same view could not be re-read for field-level verification.",
+                        "backend_code": exc.backend_code,
+                        "http_status": exc.http_status,
+                    }],
+                }
             if exc.backend_code != 40002:
                 raise
             return self._verify_record_write_result_via_initiated_tasks(
@@ -12305,7 +13484,7 @@ class RecordTools(ToolBase):
                 )
         return {
             "verified": not missing_fields and not empty_fields and not count_mismatches,
-            "verification_mode": "initiated_record_view",
+            "verification_mode": "custom_view_record_detail" if verify_view_key else "initiated_record_view",
             "field_level_verified": True,
             "missing_fields": missing_fields,
             "empty_fields": empty_fields,
@@ -13217,6 +14396,13 @@ def _record_access_run_dir() -> Path:
     return base_dir / run_id
 
 
+def _record_logs_run_dir() -> Path:
+    custom_home = os.getenv("QINGFLOW_MCP_RECORD_LOGS_HOME")
+    base_dir = Path(custom_home).expanduser() if custom_home else get_mcp_home() / "record-logs"
+    run_id = f"{datetime.now(UTC).strftime('%Y%m%dT%H%M%SZ')}-{uuid4().hex[:8]}"
+    return base_dir / run_id
+
+
 def _record_access_field_payload(field: FormField) -> JSONObject:
     return {
         "field_id": field.que_id,
@@ -13985,6 +15171,159 @@ def _record_detail_log_unavailable_payload(source: str, reason: str) -> JSONObje
     }
 
 
+def _record_logs_hidden_payload(source: str) -> JSONObject:
+    return {
+        "status": "hidden",
+        "visible": False,
+        "source": source,
+        "complete": False,
+        "items_count": 0,
+        "pages_fetched": 0,
+        "reported_total": None,
+        "local_path": None,
+        "preview_items": [],
+        "warnings": [],
+    }
+
+
+def _record_logs_unavailable_payload(source: str, reason: str) -> JSONObject:
+    return {
+        "status": "unavailable",
+        "visible": None,
+        "source": source,
+        "reason": reason,
+        "complete": False,
+        "items_count": 0,
+        "pages_fetched": 0,
+        "reported_total": None,
+        "local_path": None,
+        "preview_items": [],
+        "warnings": [],
+    }
+
+
+def _record_logs_fetch_all_to_jsonl(
+    *,
+    fetch_page,
+    normalizer,
+    source: str,
+    file_path: Path,
+    deadline: float,
+) -> JSONObject:  # type: ignore[no-untyped-def]
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    page_num = 1
+    pages_fetched = 0
+    items_count = 0
+    reported_total: int | None = None
+    preview_items: list[JSONObject] = []
+    warnings: list[JSONObject] = []
+    stopped_reason: str | None = None
+    complete = True
+
+    with file_path.open("w", encoding="utf-8") as handle:
+        while True:
+            if _record_logs_time_budget_exceeded(deadline=deadline):
+                complete = False
+                stopped_reason = "time_budget_exceeded"
+                warnings.append(_record_logs_time_budget_warning(source=source, pages_fetched=pages_fetched, items_count=items_count))
+                break
+            payload = fetch_page(page_num)
+            pages_fetched += 1
+            items = _record_detail_page_items(payload)
+            if reported_total is None:
+                reported_total = _record_detail_page_total(payload)
+            if not items:
+                break
+            for item in items:
+                normalized = normalizer(item)
+                handle.write(json.dumps(normalized, ensure_ascii=False) + "\n")
+                items_count += 1
+                if len(preview_items) < RECORD_LOGS_PREVIEW_LIMIT:
+                    preview_items.append(normalized)
+                if items_count >= RECORD_LOGS_MAX_ITEMS:
+                    complete = False
+                    stopped_reason = "item_limit_exceeded"
+                    warnings.append(_record_logs_item_limit_warning(source=source, item_limit=RECORD_LOGS_MAX_ITEMS))
+                    break
+            if stopped_reason:
+                break
+            if reported_total is not None and items_count >= reported_total:
+                break
+            if reported_total is None and len(items) < RECORD_LOGS_PAGE_SIZE:
+                break
+            page_num += 1
+
+    return {
+        "status": "ok" if complete else "partial",
+        "visible": True,
+        "source": source,
+        "complete": complete,
+        "items_count": items_count,
+        "pages_fetched": pages_fetched,
+        "page_size": RECORD_LOGS_PAGE_SIZE,
+        "reported_total": reported_total,
+        "local_path": str(file_path),
+        "preview_items": preview_items,
+        "warnings": warnings,
+        "stopped_reason": stopped_reason,
+    }
+
+
+def _record_logs_time_budget_exceeded(*, deadline: float) -> bool:
+    return time.monotonic() + RECORD_LOGS_MIN_REMAINING_SECONDS >= deadline
+
+
+def _record_logs_time_budget_warning(*, source: str, pages_fetched: int, items_count: int) -> JSONObject:
+    return {
+        "code": "RECORD_LOGS_TIME_BUDGET_EXCEEDED",
+        "source": source,
+        "message": "record_logs_get stopped early to return partial JSONL files before the caller timeout.",
+        "pages_fetched": pages_fetched,
+        "items_count": items_count,
+    }
+
+
+def _record_logs_item_limit_warning(*, source: str, item_limit: int) -> JSONObject:
+    return {
+        "code": "RECORD_LOGS_ITEM_LIMIT_EXCEEDED",
+        "source": source,
+        "message": f"record_logs_get stopped after the internal {item_limit} item limit.",
+        "item_limit": item_limit,
+    }
+
+
+def _record_logs_overall_status(*, data_logs: JSONObject, workflow_logs: JSONObject) -> str:
+    statuses = {str(data_logs.get("status") or ""), str(workflow_logs.get("status") or "")}
+    if statuses == {"unavailable"}:
+        return "unavailable"
+    if "partial" in statuses or "unavailable" in statuses:
+        return "partial"
+    return "success"
+
+
+def _record_logs_context_integrity(*, data_logs: JSONObject, workflow_logs: JSONObject) -> JSONObject:
+    data_integrity = _record_logs_section_integrity(data_logs)
+    workflow_integrity = _record_logs_section_integrity(workflow_logs)
+    return {
+        "data_logs": data_integrity,
+        "workflow_logs": workflow_integrity,
+        "safe_for_full_log_conclusion": data_integrity == "full" and workflow_integrity == "full",
+    }
+
+
+def _record_logs_section_integrity(section: JSONObject) -> str:
+    status = str(section.get("status") or "")
+    if status == "ok" and section.get("complete") is True:
+        return "full"
+    if status == "hidden":
+        return "hidden"
+    if status == "partial":
+        return "partial"
+    if status == "unavailable":
+        return "unavailable"
+    return "unknown"
+
+
 def _record_detail_log_page_payload(payload: JSONValue, *, normalizer, source: str) -> JSONObject:  # type: ignore[no-untyped-def]
     items = _record_detail_page_items(payload)
     total = _record_detail_page_total(payload)
@@ -18780,6 +20119,15 @@ def _write_format_for_field(field: FormField) -> JSONObject:
         return _write_support_payload(support_level="full", kind="boolean_label", examples=["是", "否"])
     if field.que_type in DATE_QUE_TYPES:
         return _write_support_payload(support_level="full", kind="date_string", examples=["2026-03-13 10:00:00"])
+    if field.que_type == 8:
+        allow_decimal = bool((field.raw or {}).get("canDecimal"))
+        payload = _write_support_payload(
+            support_level="full",
+            kind="amount_number",
+            examples=[100.5 if allow_decimal else 100],
+        )
+        payload["allow_decimal"] = allow_decimal
+        return payload
     return _write_support_payload(support_level="full", kind="scalar_text")
 
 
@@ -18805,6 +20153,11 @@ def _ready_schema_format_hint(kind: str, write_format: JSONObject) -> str:
     if kind == "date":
         return "推荐传 'YYYY-MM-DD HH:MM:SS'；只有日期时可传 'YYYY-MM-DD'。"
     if kind == "number":
+        write_kind = _normalize_optional_text(write_format.get("kind"))
+        if write_kind == "amount_number":
+            if bool(write_format.get("allow_decimal")):
+                return "传数字或数字字符串，支持小数。"
+            return "传整数或整数字符串；该字段后端不接受小数。"
         return "传数字或数字字符串。"
     if kind == "unsupported":
         reason = _normalize_optional_text(write_format.get("reason"))