@qingflow-tech/qingflow-cli 1.1.48 → 1.1.49

package/README.md

@@ -7,7 +7,7 @@ Qingflow CLI 是轻流面向开发者和 AI Agent 的命令行工具。它把轻
 ## 安装
 
 ```bash
-npm install @qingflow-tech/qingflow-cli@1.1.48
+npm install @qingflow-tech/qingflow-cli@1.1.49
 ```
 
 推荐从官网复制这一条一键安装 Qingflow CLI：
@@ -21,7 +21,7 @@ npx qingflow-cli@latest install
 ## 运行
 
 ```bash
-npx -y -p @qingflow-tech/qingflow-cli@1.1.48 qingflow
+npx -y -p @qingflow-tech/qingflow-cli@1.1.49 qingflow
 ```
 
 全局安装后可以直接运行：
@@ -62,7 +62,7 @@ qingflow-skills install --agent codex --scope user
 如果你通过一次性 `npx -p` 执行 skills 安装，建议加 `--copy`，避免 symlink 指向 npm 临时执行缓存：
 
 ```bash
-npx -y -p @qingflow-tech/qingflow-cli@1.1.48 qingflow-skills install --agent codex --scope user --copy
+npx -y -p @qingflow-tech/qingflow-cli@1.1.49 qingflow-skills install --agent codex --scope user --copy
 ```
 
 `qingflow-skills install` 默认使用 symlink，且遇到同名 skill 不会覆盖；只有显式传入 `--force` 才会替换。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qingflow-tech/qingflow-cli",
-  "version": "1.1.48",
+  "version": "1.1.49",
   "description": "Human-friendly Qingflow command line interface for auth, record operations, import, tasks, and stable builder flows.",
   "license": "MIT",
   "type": "module",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qingflow-mcp"
-version = "1.1.48"
+version = "1.1.49"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/src/qingflow_mcp/builder_facade/service.py

@@ -1933,6 +1933,12 @@ class AiBuilderFacade:
             "error_code": None,
             "recoverable": False,
             "message": "resolved members",
+            "pagination": {
+                **(listed.get("data", {}).get("pagination", {})),
+                "page": page_num,
+                "page_size": page_size,
+                "returned_items": len(items),
+            },
             "normalized_args": normalized_args,
             "missing_fields": [],
             "allowed_values": {},
@@ -1998,6 +2004,13 @@ class AiBuilderFacade:
             "error_code": None,
             "recoverable": False,
             "message": "resolved roles",
+            "pagination": {
+                "page": page_num,
+                "page_size": page_size,
+                "returned_items": len(items),
+                "reported_total": page.get("total"),
+                "page_amount": page.get("pageAmount"),
+            },
             "normalized_args": normalized_args,
             "missing_fields": [],
             "allowed_values": {},

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

@@ -6,6 +6,7 @@ from typing import Any
 
 from ..context import CliContext
 from ..interaction import cancelled_result, resolve_interactive_selection, resolve_interactive_text_input
+from ..pagination import collect_paginated_items
 from ..terminal_ui import SelectionOption
 from .common import load_object_arg, raise_config_error
 
@@ -264,18 +265,15 @@ def _choose_todo_task_interactively(
     title: str = "选择待办",
 ):
     def load_options() -> list[SelectionOption[str]]:
-        result = context.task.task_list(
-            profile=args.profile,
-            task_box="todo",
-            flow_status="all",
-            app_key=None,
-            workflow_node_id=None,
-            query=None,
-            page=1,
-            page_size=100,
-        )
-        data = result.get("data") if isinstance(result, dict) and isinstance(result.get("data"), dict) else {}
-        items = data.get("items") if isinstance(data.get("items"), list) else []
+        def fetch_page(page, page_size):
+            result = context.task.task_list(
+                profile=args.profile, task_box="todo", flow_status="all",
+                app_key=None, workflow_node_id=None, query=None, page=page, page_size=page_size,
+            )
+            data = result.get("data") or {}
+            return data.get("items") or [], data.get("pagination") or {}
+
+        items = collect_paginated_items(fetch_page, id_key="task_id")
         options: list[SelectionOption[str]] = []
         for item in items:
             if not isinstance(item, dict):

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

@@ -4,6 +4,7 @@ import argparse
 
 from ..context import CliContext
 from ..interaction import cancelled_result, resolve_interactive_selection
+from ..pagination import collect_paginated_items
 from ..terminal_ui import SelectionOption
 from .common import raise_config_error
 
@@ -75,13 +76,25 @@ def _choose_workspace_interactively(args: argparse.Namespace, context: CliContex
             session_profile = None
         current_ws_id = getattr(session_profile, "selected_ws_id", None) if session_profile is not None else None
     def load_options() -> list[SelectionOption[int]]:
-        page = context.workspace.workspace_list(
-            profile=args.profile,
-            page_num=1,
-            page_size=100,
-            include_external=False,
-        ).get("page")
-        items = page.get("list") if isinstance(page, dict) and isinstance(page.get("list"), list) else []
+        selected_workspace = None
+
+        def fetch_page(page_num, page_size):
+            nonlocal selected_workspace
+            result = context.workspace.workspace_list(
+                profile=args.profile, page_num=page_num, page_size=page_size, include_external=False,
+            )
+            if page_num == 1:
+                selected_workspace = result.get("selected_workspace")
+            page = result.get("page") or {}
+            return page.get("list") or [], {
+                "page_amount": page.get("pageAmount"),
+                "reported_total": page.get("total"),
+                "page_size": page.get("pageSize"),
+            }
+
+        items = collect_paginated_items(fetch_page, id_key="wsId")
+        if isinstance(selected_workspace, dict) and not any(item.get("wsId") == selected_workspace.get("wsId") for item in items):
+            items.append(selected_workspace)
         options: list[SelectionOption[int]] = []
         for item in items:
             if not isinstance(item, dict):

package/src/qingflow_mcp/cli/formatters.py

@@ -147,7 +147,11 @@ def _format_workspace_list(result: dict[str, Any]) -> str:
                 str(item.get("remark") or ""),
             ]
         )
-    return _render_titled_table("Workspaces", ["ws_id", "name", "remark"], rows)
+    text = _render_titled_table("Workspaces", ["ws_id", "name", "remark"], rows)
+    selected = result.get("selected_workspace")
+    if isinstance(selected, dict):
+        text += f"Selected Workspace: {selected.get('wsId')} / {selected.get('workspaceName') or '-'}\n"
+    return text
 
 
 def _format_workspace_get(result: dict[str, Any]) -> str:
@@ -356,11 +360,9 @@ def _format_record_list(result: dict[str, Any]) -> str:
         lines.append(f"- returned_count: {lookup.get('returned_count')}")
         lines.append(f"- truncated: {lookup.get('truncated')}")
     lines.append(f"Returned Records: {len(items)}")
-    for item in items[:10]:
+    for item in items:
         if isinstance(item, dict):
             lines.append(json.dumps(item, ensure_ascii=False))
-    if len(items) > 10:
-        lines.append(f"... {len(items) - 10} more")
     _append_warnings(lines, result.get("warnings"))
     _append_verification(lines, result.get("verification"))
     return "\n".join(lines) + "\n"
@@ -421,10 +423,11 @@ def _format_record_candidates(result: dict[str, Any]) -> str:
             f"page_size={pagination.get('page_size')} / "
             f"returned={pagination.get('returned_items')} / "
             f"total={pagination.get('reported_total')} / "
-            f"pages={pagination.get('page_amount')}"
+            f"pages={pagination.get('page_amount')} / "
+            f"has_more={pagination.get('has_more')}"
         )
     lines.append(f"Candidates: {len(items)}")
-    for item in items[:20]:
+    for item in items:
         if not isinstance(item, dict):
             lines.append(f"- {item}")
             continue
@@ -446,8 +449,6 @@ def _format_record_candidates(result: dict[str, Any]) -> str:
         if source_labels:
             parts.append("sources=" + ",".join(source_labels))
         lines.append("- " + " / ".join(parts))
-    if len(items) > 20:
-        lines.append(f"... {len(items) - 20} more")
     _append_warnings(lines, result.get("warnings"))
     _append_verification(lines, result.get("verification"))
     return "\n".join(lines) + "\n"
@@ -944,11 +945,9 @@ def _format_task_associated_report_detail(result: dict[str, Any]) -> str:
         result_payload = data.get("result") if isinstance(data.get("result"), dict) else {}
         items = result_payload.get("items") if isinstance(result_payload.get("items"), list) else []
         lines.append(f"Returned Records: {len(items)}")
-        for item in items[:10]:
+        for item in items:
             if isinstance(item, dict):
                 lines.append(json.dumps(item, ensure_ascii=False))
-        if len(items) > 10:
-            lines.append(f"... {len(items) - 10} more")
     elif result_type == "chart_data":
         result_payload = data.get("result") if isinstance(data.get("result"), dict) else {}
         summary = result_payload.get("summary") if isinstance(result_payload.get("summary"), dict) else {}
@@ -956,11 +955,9 @@ def _format_task_associated_report_detail(result: dict[str, Any]) -> str:
         if summary:
             lines.append(f"Summary: {json.dumps(summary, ensure_ascii=False)}")
         lines.append(f"Rows: {len(rows)}")
-        for row in rows[:10]:
+        for row in rows:
             if isinstance(row, dict):
                 lines.append(json.dumps(row, ensure_ascii=False))
-        if len(rows) > 10:
-            lines.append(f"... {len(rows) - 10} more")
     resolved_filters = context.get("resolved_filters") if isinstance(context.get("resolved_filters"), list) else []
     if resolved_filters:
         lines.append(f"Resolved Filters: {len(resolved_filters)}")
@@ -1175,6 +1172,9 @@ def _format_export_direct(result: dict[str, Any]) -> str:
 
 def _format_builder_summary(result: dict[str, Any]) -> str:
     lines = []
+    pagination = result.get("pagination")
+    if isinstance(pagination, dict):
+        lines.append("Pagination: " + json.dumps(pagination, ensure_ascii=False))
     emitted: set[str] = set()
     for key, label in (
         ("status", "Status"),
@@ -1222,10 +1222,11 @@ def _format_builder_summary(result: dict[str, Any]) -> str:
             value = data.get(key)
         if isinstance(value, list):
             lines.append(f"{key}: {len(value)}")
-            for item in value[:8]:
+            visible_items = value if isinstance(pagination, dict) else value[:8]
+            for item in visible_items:
                 lines.append("- " + _builder_item_summary(item))
-            if len(value) > 8:
-                lines.append(f"... {len(value) - 8} more")
+            if len(value) > len(visible_items):
+                lines.append(f"... {len(value) - len(visible_items)} more")
     components = result.get("components") if isinstance(result.get("components"), list) else []
     if components:
         lines.append("Component Refs:")

package/src/qingflow_mcp/cli/pagination.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from .commands.common import raise_config_error
+
+
+def collect_paginated_items(
+    fetch_page: Callable[[int, int], tuple[list[dict[str, Any]], dict[str, Any]]],
+    *,
+    id_key: str,
+    page_size: int = 100,
+) -> list[dict[str, Any]]:
+    items: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    page = 1
+    fetched_count = 0
+    while True:
+        rows, pagination = fetch_page(page, page_size)
+        previous_count = len(items)
+        for row in rows:
+            if not isinstance(row, dict):
+                continue
+            key = str(row.get(id_key) or "")
+            if key and key not in seen:
+                seen.add(key)
+                items.append(row)
+        fetched_count += len(rows)
+        page_amount = pagination.get("page_amount")
+        total = pagination.get("reported_total")
+        if not rows:
+            break
+        if len(items) == previous_count:
+            raise_config_error("Pagination did not advance; the backend returned the same items again.")
+        if page_amount is not None:
+            if page >= int(page_amount):
+                break
+        elif total is not None:
+            if fetched_count >= int(total):
+                break
+        elif len(rows) < int(pagination.get("page_size") or page_size):
+            break
+        page += 1
+    return items

package/src/qingflow_mcp/response_trim.py

@@ -313,6 +313,9 @@ def _trim_workspace_list(payload: JSONObject) -> None:
     page = payload.get("page")
     if isinstance(page, dict):
         _trim_item_list(page, "list", allowed=("wsId", "workspaceName", "remark"))
+    selected = payload.get("selected_workspace")
+    if isinstance(selected, dict):
+        payload["selected_workspace"] = _pick(selected, allowed=("wsId", "workspaceName", "remark"))
 
 
 def _trim_workspace_get(payload: JSONObject) -> None:

package/src/qingflow_mcp/tools/record_tools.py

@@ -442,7 +442,7 @@ class RecordTools(ToolBase):
             description=(
                 "Browse Qingflow records with a schema-first list DSL. "
                 "Use record_browse_schema_get first, then pass field_id-only columns, where, and order_by clauses. "
-                "This route returns up to 10 rows plus total counts for browse, sample inspection, and fuzzy record lookup; it is not for analysis."
+                "This route returns one page (10 rows by default) plus total counts for browse, sample inspection, and fuzzy record lookup; it is not for analysis."
             )
         )
         def record_list(
@@ -1525,6 +1525,7 @@ class RecordTools(ToolBase):
             )
             warnings: list[JSONObject] = []
             scope_source = "static_applicant_scope"
+            backend_pagination: JSONObject = {}
             try:
                 if runtime_lookup:
                     state = self._build_candidate_lookup_state(
@@ -1535,7 +1536,10 @@ class RecordTools(ToolBase):
                         workflow_node_id=workflow_node_id,
                         fields=normalized_fields,
                     )
-                    items = self._resolve_member_candidates_backend(context, field, keyword=keyword, state=state)
+                    items = self._resolve_member_candidates_backend(
+                        context, field, keyword=keyword, state=state,
+                        page_num=page_num, page_size=page_size, pagination=backend_pagination,
+                    )
                     scope_source = "backend_runtime_scope"
                 else:
                     items: list[JSONObject] | None = None
@@ -1548,7 +1552,10 @@ class RecordTools(ToolBase):
                             workflow_node_id=None,
                             fields={},
                         )
-                        items = self._resolve_member_candidates_backend(context, field, keyword=keyword, state=state)
+                        items = self._resolve_member_candidates_backend(
+                            context, field, keyword=keyword, state=state,
+                            page_num=page_num, page_size=page_size, pagination=backend_pagination,
+                        )
                         scope_source = "backend_applicant_scope"
                     if items is None:
                         items = self._resolve_member_candidates(context, field, keyword=keyword)
@@ -1581,7 +1588,7 @@ class RecordTools(ToolBase):
             total = len(items)
             start = (page_num - 1) * page_size
             end = start + page_size
-            page_items = items[start:end]
+            page_items = items if backend_pagination else items[start:end]
             page_amount = (total + page_size - 1) // page_size if total else 0
             return {
                 "profile": profile,
@@ -1598,6 +1605,7 @@ class RecordTools(ToolBase):
                         "returned_items": len(page_items),
                         "reported_total": total,
                         "page_amount": page_amount,
+                        **backend_pagination,
                     },
                     "selection": {
                         "app_key": app_key,
@@ -1668,6 +1676,7 @@ class RecordTools(ToolBase):
             )
             warnings: list[JSONObject] = []
             scope_source = "static_applicant_scope"
+            backend_pagination: JSONObject = {}
             try:
                 if runtime_lookup:
                     state = self._build_candidate_lookup_state(
@@ -1678,7 +1687,10 @@ class RecordTools(ToolBase):
                         workflow_node_id=workflow_node_id,
                         fields=normalized_fields,
                     )
-                    items = self._resolve_department_candidates_backend(context, field, keyword=keyword, state=state)
+                    items = self._resolve_department_candidates_backend(
+                        context, field, keyword=keyword, state=state,
+                        page_num=page_num, page_size=page_size, pagination=backend_pagination,
+                    )
                     scope_source = "backend_runtime_scope"
                 else:
                     items: list[JSONObject] | None = None
@@ -1691,7 +1703,10 @@ class RecordTools(ToolBase):
                             workflow_node_id=None,
                             fields={},
                         )
-                        items = self._resolve_department_candidates_backend(context, field, keyword=keyword, state=state)
+                        items = self._resolve_department_candidates_backend(
+                            context, field, keyword=keyword, state=state,
+                            page_num=page_num, page_size=page_size, pagination=backend_pagination,
+                        )
                         scope_source = "backend_applicant_scope"
                     if items is None:
                         items = self._resolve_department_candidates(context, field, keyword=keyword)
@@ -1710,7 +1725,10 @@ class RecordTools(ToolBase):
                                 workflow_node_id=None,
                                 fields={},
                             )
-                            items = self._resolve_department_candidates_backend(context, field, keyword=keyword, state=state)
+                            items = self._resolve_department_candidates_backend(
+                                context, field, keyword=keyword, state=state,
+                                page_num=page_num, page_size=page_size, pagination=backend_pagination,
+                            )
                             scope_source = "backend_applicant_scope"
                     warnings.append(
                         {
@@ -1741,7 +1759,7 @@ class RecordTools(ToolBase):
             total = len(items)
             start = (page_num - 1) * page_size
             end = start + page_size
-            page_items = items[start:end]
+            page_items = items if backend_pagination else items[start:end]
             page_amount = (total + page_size - 1) // page_size if total else 0
             return {
                 "profile": profile,
@@ -1758,6 +1776,7 @@ class RecordTools(ToolBase):
                         "returned_items": len(page_items),
                         "reported_total": total,
                         "page_amount": page_amount,
+                        **backend_pagination,
                     },
                     "selection": {
                         "app_key": app_key,
@@ -1888,7 +1907,7 @@ class RecordTools(ToolBase):
         query_fields: list[JSONObject | int] | None = None,
         where: list[JSONObject],
         order_by: list[JSONObject],
-        limit: int = DEFAULT_RECORD_LIST_RETURN_LIMIT,
+        limit: int | None = None,
         page: int = 1,
         page_size: int = DEFAULT_RECORD_LIST_RETURN_LIMIT,
         view_id: str | None = None,
@@ -1905,12 +1924,14 @@ class RecordTools(ToolBase):
         normalized_columns = _normalize_public_column_selectors(columns)
         normalized_query = _normalize_optional_text(query)
         normalized_query_field_selectors = _normalize_public_query_field_selectors(query_fields or [])
-        if limit <= 0:
+        if limit is not None and limit <= 0:
             raise_tool_error(QingflowApiError.config_error("limit must be positive"))
         if page <= 0:
             raise_tool_error(QingflowApiError.config_error("page must be positive"))
         if page_size <= 0:
             raise_tool_error(QingflowApiError.config_error("page_size must be positive"))
+        if limit is not None:
+            page_size = min(limit, page_size)
         if not (
             _normalize_optional_text(view_id)
             or list_type is not None
@@ -1989,7 +2010,7 @@ class RecordTools(ToolBase):
                 search_que_ids=resolved_query_fields or None,
                 match_rules=match_rules,
                 sort_rules=sort_rules,
-                max_rows=min(limit, page_size),
+                max_rows=page_size,
                 selected_fields=selected_fields,
                 output_profile="verbose" if normalized_output_profile in {"verbose", "normalized"} else DEFAULT_OUTPUT_PROFILE,
             )
@@ -13314,6 +13335,9 @@ class RecordTools(ToolBase):
         *,
         keyword: str,
         state: LookupResolutionState,
+        page_num: int = 1,
+        page_size: int = LOOKUP_RELATION_FILTER_PAGE_SIZE,
+        pagination: JSONObject | None = None,
     ) -> list[JSONObject]:
         """执行内部辅助逻辑。"""
         scope = field.member_select_scope if isinstance(field.member_select_scope, dict) else {}
@@ -13321,7 +13345,9 @@ class RecordTools(ToolBase):
             isinstance(scope.get("externalMemberList"), list) and scope.get("externalMemberList")
             or isinstance(scope.get("externalDepartList"), list) and scope.get("externalDepartList")
         )
-        payload = self._build_lookup_scope_payload(state, keyword=keyword, que_id=field.que_id)
+        payload = self._build_lookup_scope_payload(
+            state, keyword=keyword, que_id=field.que_id, page_num=page_num, page_size=page_size,
+        )
         route = f"/data/que/{field.que_id}/external/memberSelectScope" if use_external else f"/data/que/{field.que_id}/memberSelectScope"
         try:
             result = self.backend.request("POST", context, route, json_body=payload)
@@ -13334,7 +13360,10 @@ class RecordTools(ToolBase):
                     details={"field": _field_ref_payload(field), "received_value": keyword, "candidate_error": exc.to_dict()},
                 )
             self._raise_candidate_lookup_failed(kind="member", field=field, value=keyword, error=exc)
-        return self._normalize_backend_member_candidates(result, external=use_external)
+        items = self._normalize_backend_member_candidates(result, external=use_external)
+        if pagination is not None:
+            pagination.update(_candidate_page_metadata(result, page_num=page_num, page_size=page_size, returned_items=len(items)))
+        return items
 
     def _member_confirmation_candidates(self, candidates: list[JSONObject]) -> list[JSONObject]:
         """执行内部辅助逻辑。"""
@@ -13603,16 +13632,24 @@ class RecordTools(ToolBase):
         *,
         keyword: str,
         state: LookupResolutionState,
+        page_num: int = 1,
+        page_size: int = LOOKUP_RELATION_FILTER_PAGE_SIZE,
+        pagination: JSONObject | None = None,
     ) -> list[JSONObject]:
         """执行内部辅助逻辑。"""
         scope = field.dept_select_scope if isinstance(field.dept_select_scope, dict) else {}
         external = bool(
             isinstance(scope.get("externalDepartList"), list) and scope.get("externalDepartList")
         )
-        payload = self._build_lookup_scope_payload(state, keyword=keyword, que_id=field.que_id)
+        payload = self._build_lookup_scope_payload(
+            state, keyword=keyword, que_id=field.que_id, page_num=page_num, page_size=page_size,
+        )
         payload["deptScope"] = "EXTERNAL" if external else "INTERNAL"
         result = self.backend.request("POST", context, "/data/deptSelectScope/search", json_body=payload)
-        return self._normalize_backend_department_candidates(result, external=external)
+        items = self._normalize_backend_department_candidates(result, external=external)
+        if pagination is not None:
+            pagination.update(_candidate_page_metadata(result, page_num=page_num, page_size=page_size, returned_items=len(items)))
+        return items
 
     def _department_confirmation_candidates(self, candidates: list[JSONObject]) -> list[JSONObject]:
         """执行内部辅助逻辑。"""
@@ -17881,6 +17918,28 @@ def _normalize_public_record_rows(rows: list[JSONValue]) -> list[JSONObject]:
     return normalized_rows
 
 
+def _candidate_page_metadata(
+    payload: JSONValue, *, page_num: int, page_size: int, returned_items: int,
+) -> JSONObject:
+    page = payload if isinstance(payload, dict) else {}
+    total = _coerce_count(page.get("total"))
+    page_amount = _coerce_count(page.get("pageAmount"))
+    # Some member-scope endpoints return rows without a total. A full page is not a total.
+    if total is None and returned_items < page_size and (page_num == 1 or returned_items > 0):
+        total = (page_num - 1) * page_size + returned_items
+    if page_amount is None and total is not None:
+        page_amount = (total + page_size - 1) // page_size
+    has_more = page_num < page_amount if page_amount is not None else returned_items >= page_size
+    return {
+        "page": page_num,
+        "page_size": page_size,
+        "returned_items": returned_items,
+        "reported_total": total,
+        "page_amount": page_amount,
+        "has_more": has_more,
+    }
+
+
 def _build_record_list_lookup_payload(
     *,
     query: str | None,

package/src/qingflow_mcp/tools/task_context_tools.py

@@ -201,7 +201,15 @@ class TaskContextTools(ToolBase):
         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:
+        search_has_no_matches = not items and not (_coerce_count(reported_total) or 0)
+        if query and search_has_no_matches and page > 1:
+            first_page = 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=query, page=1, page_size=page_size,
+            )
+            search_has_no_matches = not first_page["items"] and not (_coerce_count(first_page.get("reported_total")) or 0)
+        if query and search_has_no_matches:
             fallback = self._task_list_local_query_fallback(
                 profile=profile,
                 task_box=task_box,
@@ -1238,6 +1246,7 @@ class TaskContextTools(ToolBase):
         scan_page = 1
         page_amount: int | None = None
         matched_items: list[dict[str, Any]] = []
+        scanned_items = 0
         while True:
             response = self._list_normalized_task_items(
                 profile=profile,
@@ -1250,14 +1259,22 @@ class TaskContextTools(ToolBase):
                 page_size=scan_page_size,
             )
             normalized_items = response.get("items") if isinstance(response.get("items"), list) else []
+            scanned_items += len(normalized_items)
             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:
+            if not normalized_items:
                 break
-            if not normalized_items or len(normalized_items) < scan_page_size:
+            reported_total = _coerce_count(response.get("reported_total"))
+            if page_amount is not None:
+                if scan_page >= page_amount:
+                    break
+            elif reported_total is not None:
+                if scanned_items >= reported_total:
+                    break
+            elif len(normalized_items) < scan_page_size:
                 break
             scan_page += 1
         if not matched_items:
@@ -1527,7 +1544,7 @@ class TaskContextTools(ToolBase):
             if report_item.get("graph_type") == "view":
                 viewgraph_key = str(report_item.get("chart_key") or "")
                 body = {
-                    "filter": {},
+                    "filter": {"pageNum": page, "pageSize": page_size},
                     "viewgraphKey": viewgraph_key,
                     "equipmentType": 0,
                     "associationQuery": association_query,

package/src/qingflow_mcp/tools/workspace_tools.py

@@ -94,8 +94,13 @@ class WorkspaceTools(ToolBase):
             normalized = result if isinstance(result, dict) else {"list": result if isinstance(result, list) else []}
             workspace_list = normalized.get("list") if isinstance(normalized.get("list"), list) else []
             selected_ws_id = _.selected_ws_id if _ is not None else None
+            selected_in_page = bool(
+                selected_ws_id
+                and any(isinstance(item, dict) and item.get("wsId") == selected_ws_id for item in workspace_list)
+            )
             warnings: list[dict[str, Any]] = []
-            if selected_ws_id and not any(isinstance(item, dict) and item.get("wsId") == selected_ws_id for item in workspace_list):
+            selected_workspace = None
+            if page_num == 1 and selected_ws_id and not selected_in_page:
                 try:
                     selected_workspace = self.backend.request("GET", context, f"/user/workspace/{selected_ws_id}")
                 except QingflowApiError as exc:
@@ -106,23 +111,15 @@ class WorkspaceTools(ToolBase):
                         "wsId": selected_ws_id,
                         "workspaceName": _.selected_ws_name if _ is not None else None,
                     }
-                if isinstance(selected_workspace, dict):
-                    workspace_list.append(selected_workspace)
-                    normalized["list"] = workspace_list
-                    total = normalized.get("total")
-                    if isinstance(total, int):
-                        normalized["total"] = total + 1
             return {
                 "profile": profile,
                 "include_external": include_external,
                 "page": normalized,
+                "selected_workspace": selected_workspace,
                 "warnings": warnings,
                 "verification": {
-                    "selected_workspace_detail_verified": not warnings,
-                    "selected_workspace_included": bool(
-                        selected_ws_id
-                        and any(isinstance(item, dict) and item.get("wsId") == selected_ws_id for item in workspace_list)
-                    ),
+                    "selected_workspace_detail_verified": not warnings and (selected_in_page or isinstance(selected_workspace, dict)),
+                    "selected_workspace_included": selected_in_page,
                 },
             }