@qingflow-tech/qingflow-cli 1.1.48-beta.2 → 1.1.48-beta.4

package/README.md

@@ -7,7 +7,7 @@ Qingflow CLI 是轻流面向开发者和 AI Agent 的命令行工具。它把轻
 ## 安装
 
 ```bash
-npm install @qingflow-tech/qingflow-cli@1.1.48-beta.2
+npm install @qingflow-tech/qingflow-cli@1.1.48-beta.4
 ```
 
 推荐从官网复制这一条一键安装 Qingflow CLI：
@@ -21,7 +21,7 @@ npx qingflow-cli@latest install
 ## 运行
 
 ```bash
-npx -y -p @qingflow-tech/qingflow-cli@1.1.48-beta.2 qingflow
+npx -y -p @qingflow-tech/qingflow-cli@1.1.48-beta.4 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-beta.2 qingflow-skills install --agent codex --scope user --copy
+npx -y -p @qingflow-tech/qingflow-cli@1.1.48-beta.4 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-beta.2",
+  "version": "1.1.48-beta.4",
   "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.48b2"
+version = "1.1.48b4"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/skills/qingflow-cli/SKILL.md

@@ -9,13 +9,13 @@ description: |
 
 > **Skill 版本**：`qingflow-skills-2026.09.22.01`。CLI 实际版本与安装路径以 `qingflow --json version` 为准。
 
-选择 CLI 或 MCP 前先读 [$qingflow-common](../qingflow-common/SKILL.md)。本 Skill 只负责 CLI 入口、文件约定和业务分流；字段能力、权限范围与参数形状以当前 `--help`、data schema 和实际响应为准。
+本 Skill 负责 CLI 入口、文件约定和业务分流。已知 `app_key` 时直接执行 `data query/get`；字段能力、权限范围与下一步动作以当前工具 schema、data 响应和 `hints` 为准。
 
 ## CLI 执行与 JSON 落盘
 
 1. 已知业务目标时直接执行目标命令，不固定前置 `auth whoami`、`workspace get` 或 `workspace select`。只有业务命令明确返回未登录、会话失效或工作区错误后，才恢复上下文并重试原命令。
 2. 自动化始终使用 `--json`。`data query/get`、task 查询、record 日志/附件上下文、import 与 builder 大响应必须写入本地文件，禁止把整段 JSON 或 CSV 打到上下文。
-3. `where`、`sort`、`columns`、`items`、`fields` 等结构化参数写入独立 JSON 文件，再通过 `--*-file` 传入。参数名和 JSON 形状以当前子命令 `--help` 和对应响应为准。
+3. `where`、`sort`、`columns`、`items`、`fields` 等结构化参数写入独立 JSON 文件，再通过 `--*-file` 传入。工具已暴露参数 schema 时直接使用；只有命令缺失或参数被拒绝时才读取对应 `--help`。
 4. 多任务或目录可能变化时使用绝对路径；单线程本地执行至少先固定 `pwd`。解析时只读取目标字段，不要 `cat` 大文件。
 5. `--json` 模式的业务错误通常也在 stdout JSON 信封中；stderr 主要用于 argparse usage。写命令返回已执行、部分成功或状态不明时，不得重放原请求。
 
@@ -46,8 +46,8 @@ echo "$QINGFLOW_CREDENTIAL" | qingflow --profile default auth use-credential \
 | 待办、已办、抄送、审批、转交或退回 | `qingflow task ...` | [任务上下文 SOP](./reference/task/QINGFLOW_CLI_TASK_CONTEXT_WORKFLOW.md) |
 | Excel 模板、文件校验、修复、启动导入与状态 | `qingflow import ...` / `record schema import` | [批量导入 SOP](./reference/record/QINGFLOW_CLI_RECORD_IMPORT_WORKFLOW.md) |
 | 应用、表单、字段、视图、报表、门户与流程搭建 | `qingflow builder ...` | [Builder 总导航](./reference/builder/README.md) |
-| 完整数据／流程日志 | `qingflow record logs` | [record 专项参考](./reference/record/QINGFLOW_CLI_LEGACY_RECORD_RETRIEVAL_WORKFLOW.md) |
-| 附件、图片与详情页上下文 | `qingflow record get` | [record 专项参考](./reference/record/QINGFLOW_CLI_LEGACY_RECORD_RETRIEVAL_WORKFLOW.md) |
+| 完整数据／流程日志 | `qingflow record logs` | [record 专项参考](./reference/record/QINGFLOW_CLI_RECORD_SPECIALIZED_WORKFLOW.md) |
+| 附件、图片与详情页上下文 | `qingflow record get` | [record 专项参考](./reference/record/QINGFLOW_CLI_RECORD_SPECIALIZED_WORKFLOW.md) |
 | 代码块字段执行 | `qingflow record code-block-run` | [代码集成说明](./reference/builder/code-integrations/README.md) |
 | 安装、版本或命令能力确认 | `qingflow --json version` / `qingflow ... --help` | [命令索引](./reference/00-INDEX.md) |
 
@@ -97,7 +97,7 @@ qingflow --json data query \
 
 ### 分页
 
-先请求第一页；仅当响应 `records.has_more=true` 时增加 `--page`。同时读取 `hints`，若提示收窄范围、调整参数或停止继续，则按提示处理，不凭总数猜页数。
+先请求第一页，并按响应 `hints` 执行：`RESULT_IS_PARTIAL` 时保持筛选与排序继续下一页，`RESULT_IS_COMPLETE` 时立即停止；不凭总数猜页数。
 
 ```bash
 qingflow --json data query --app-key APP_KEY --page 1 --page-size 100 \
@@ -132,11 +132,11 @@ qingflow --json data query \
 - 导出／下载只有用户明确需要文件时才使用，并按对应命令要求提供视图上下文；不要把导出当作普通查询或统计分析默认入口。
 - 查看视图时，`baseInfo` 或 `viewConfig` 只有 40002 / 40027 / 404 这类权限/缺失边界可用另一侧降级，非权限类后端错误不隐藏；完整规则见 Builder 视图文档。
 
-## record 专项与显式命令
+## record 专项
 
-`record` 用于完整数据／流程日志、附件和图片上下文、代码块字段执行、导入专项，以及用户明确指定 `record` 命令的场景。
+`record` 用于完整数据／流程日志、附件和图片上下文、代码块字段执行，以及用户指定的 `record` 操作。
 
-普通应用数据默认使用 `data`。不得在 data 失败后自动改用 `record list/access/get/insert/update/delete` 绕过权限或校验。用户明确指定 `record` 查询时阅读 [record 专项参考](./reference/record/QINGFLOW_CLI_LEGACY_RECORD_RETRIEVAL_WORKFLOW.md)；`record delete` 提交不要传 `custom:*`、`list_type`，细则见 [record 删除参考](./reference/record/QINGFLOW_CLI_RECORD_DELETE_WORKFLOW.md)。
+普通应用数据使用 `data`。不得改用 `record list/access/get/insert/update/delete` 绕过 data 返回的权限、字段能力或校验结果。日志与附件操作阅读 [record 专项参考](./reference/record/QINGFLOW_CLI_RECORD_SPECIALIZED_WORKFLOW.md)；`record delete` 提交不要传 `custom:*`、`list_type`，细则见 [record 删除参考](./reference/record/QINGFLOW_CLI_RECORD_DELETE_WORKFLOW.md)。
 
 ## 关联入口
 
@@ -146,6 +146,6 @@ qingflow --json data query \
 - [批量导入 SOP](./reference/record/QINGFLOW_CLI_RECORD_IMPORT_WORKFLOW.md)
 - [数据分析说明](./reference/record/analysis/README.md)
 - [Builder 总导航](./reference/builder/README.md)
-- [record 专项参考](./reference/record/QINGFLOW_CLI_LEGACY_RECORD_RETRIEVAL_WORKFLOW.md)
+- [record 专项参考](./reference/record/QINGFLOW_CLI_RECORD_SPECIALIZED_WORKFLOW.md)
 
 维护时用 `qingflow --json version`、`qingflow data --help` 与对应专项 `--help` 复核，不根据历史文档补造参数。

package/skills/qingflow-cli/reference/QINGFLOW_CLI_DATA_RETRIEVAL_WORKFLOW.md

@@ -2,4 +2,4 @@
 
 普通应用数据查询默认使用 `data query/get`。完整流程、JSON 形状、分页与分析边界见 [core/QINGFLOW_CLI_DATA_RETRIEVAL_WORKFLOW.md](./core/QINGFLOW_CLI_DATA_RETRIEVAL_WORKFLOW.md)。
 
-用户明确指定 `record` 查询命令，或需要日志、附件和图片上下文时，使用 [record 专项参考](./record/QINGFLOW_CLI_LEGACY_RECORD_RETRIEVAL_WORKFLOW.md)。
+需要完整日志、附件和图片上下文时，使用 [record 专项参考](./record/QINGFLOW_CLI_RECORD_SPECIALIZED_WORKFLOW.md)。

package/skills/qingflow-cli/reference/core/QINGFLOW_CLI_DATA_RETRIEVAL_WORKFLOW.md

@@ -2,7 +2,7 @@
 
 > **用途**：使用视图无关的 `data query/get` 完成普通应用数据查询、筛选、排序、分页和单条读取。
 > **边界**：本文只给流程与 JSON 形状；操作符、字段类型、权限范围和动态限制以当前 `--help`、`schema`、`field_capabilities`、`access` 与 `hints` 为准。
-> **record 专项**：用户明确指定 `record` 命令，或需要完整日志、附件／图片上下文时，阅读 [record 专项参考](../record/QINGFLOW_CLI_LEGACY_RECORD_RETRIEVAL_WORKFLOW.md)。
+> **record 专项**：需要完整日志、附件／图片上下文时，阅读 [record 专项参考](../record/QINGFLOW_CLI_RECORD_SPECIALIZED_WORKFLOW.md)。
 
 ## 推荐顺序
 

package/skills/qingflow-cli/reference/data/README.md

@@ -8,7 +8,7 @@
 - `qingflow data update`
 - `qingflow data delete`
 
-参数、JSON 文件形状和可选项必须来自当次 `--help` 或工具返回的 schema，不得根据旧 `record` 命令猜测。
+参数、JSON 文件形状和可选项必须来自当前工具 schema、当次 `--help` 或响应字段能力，不得从其他命令推测。
 
 ## 字段能力合同
 
@@ -23,7 +23,7 @@
 - 定位目标记录时先 query，再按需 get。字段只使用当前 schema 与字段能力允许的 id、能力和形状。
 - insert、update、delete 会改变真实业务数据。删除、覆盖已有值或批量写入前，必须确认目标和影响范围。
 - 返回后先检查 `write_executed`、`retry_safe`、字段错误和 hints。已执行、部分成功或状态不明时不得重放原请求。
-- data 命令失败时只修正响应明确指出的问题，不得自动回退旧 `record` 写入链路绕过权限或校验。
+- data 命令失败时只修正响应明确指出的问题，不得切换其他数据入口绕过权限或校验。
 
 ## 任务分流
 

package/skills/qingflow-cli/reference/record/{QINGFLOW_CLI_LEGACY_RECORD_RETRIEVAL_WORKFLOW.md → QINGFLOW_CLI_RECORD_SPECIALIZED_WORKFLOW.md}

@@ -1,6 +1,6 @@
-# Qingflow CLI：record 专项与显式命令参考
+# Qingflow CLI：record 日志与附件参考
 
-> **适用范围**：用户明确指定 `record` 命令，或任务需要完整数据／流程日志、附件和图片上下文时使用。普通应用数据查询使用 [`data query/get`](../core/QINGFLOW_CLI_DATA_RETRIEVAL_WORKFLOW.md)，不得在 data 失败后自动改用本文链路。
+> **适用范围**：任务需要完整数据／流程日志、附件或图片上下文时使用。普通应用数据查询使用 [`data query/get`](../core/QINGFLOW_CLI_DATA_RETRIEVAL_WORKFLOW.md)。
 
 ## record 查询链
 

package/src/qingflow_mcp/builder_facade/service.py

@@ -2008,6 +2008,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": {},
@@ -2073,6 +2079,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

@@ -236,7 +236,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:
@@ -448,11 +452,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"
@@ -513,10 +515,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
@@ -538,8 +541,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"
@@ -1036,11 +1037,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 {}
@@ -1048,11 +1047,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)}")
@@ -1267,6 +1264,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"),
@@ -1316,10 +1316,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")
             if key == "apps":
                 uri_lines = [
                     line

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/data_tools.py

@@ -207,6 +207,8 @@ class DataTools(ToolBase):
                 "ok": True, "status": "needs_scope", "app_key": app_key, "format": "csv", "row_count": 0,
                 "complete": False, "truncated": True, "safe_for_final_conclusion": False, "files": [],
                 "hints": probe.get("hints", []),
+                "schema": probe.get("schema", {}),
+                "field_capabilities": probe.get("field_capabilities", []),
                 "scope": {"reported_total": total, "row_threshold": DATA_UNBOUNDED_ROW_THRESHOLD},
             }, profile, ws_id)
         schema = probe.get("schema") if isinstance(probe.get("schema"), dict) else {}
@@ -216,15 +218,25 @@ class DataTools(ToolBase):
         columns = [(str(field.get("field_id")), str(field.get("title") or field.get("field_id"))) for field in business_fields]
         header = ["record_id"] + [f"{title}__field_{field_id}" for field_id, title in columns]
         run_dir = Path.home() / ".qingflow" / "data-exports" / datetime.now().strftime("%Y%m%d-%H%M%S-%f")
+        latest_hints = probe.get("hints", [])
+        latest_schema = schema
+        latest_capabilities = probe.get("field_capabilities", [])
 
         def fetch_page(page: int, page_size: int) -> JSONObject:
+            nonlocal latest_hints, latest_schema, latest_capabilities
             request_body = dict(body)
-            request_body.update({"page": page, "page_size": page_size, "include_schema": page == 1})
+            # 每页都请求 schema，使最后一页的后端原始 hints 同时准确表达完整性和字段能力。
+            request_body.update({"page": page, "page_size": page_size, "include_schema": True})
             response = self._request_data_plane(
                 context, "POST", self._base_path(app_key) + "/query", json_body=request_body
             )
             if response.get("ok") is False:
                 raise CsvPageFailure(response)
+            latest_hints = response.get("hints", [])
+            if isinstance(response.get("schema"), dict):
+                latest_schema = response["schema"]
+            if isinstance(response.get("field_capabilities"), list):
+                latest_capabilities = response["field_capabilities"]
             return response
 
         def project_row(record: JSONObject) -> list[str]:
@@ -239,7 +251,8 @@ class DataTools(ToolBase):
         page_error = exported.pop("page_error", None)
         result: JSONObject = {
             "ok": True, "status": "success" if exported["complete"] else "partial", "app_key": app_key,
-            "format": "csv", "local_dir": str(run_dir), "fields": business_fields, "hints": probe.get("hints", []),
+            "format": "csv", "local_dir": str(run_dir), "fields": business_fields,
+            "schema": latest_schema, "field_capabilities": latest_capabilities, "hints": latest_hints,
             **exported,
         }
         if isinstance(page_error, dict):

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,
             )
@@ -13279,6 +13300,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 {}
@@ -13286,7 +13310,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)
@@ -13299,7 +13325,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]:
         """执行内部辅助逻辑。"""
@@ -13568,16 +13597,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]:
         """执行内部辅助逻辑。"""
@@ -17846,6 +17883,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,
                 },
             }