@josephyan/qingflow-app-user-mcp 0.2.0-beta.995 → 0.2.0-beta.997

package/README.md

@@ -3,13 +3,13 @@
 Install:
 
 ```bash
-npm install @josephyan/qingflow-app-user-mcp@0.2.0-beta.995
+npm install @josephyan/qingflow-app-user-mcp@0.2.0-beta.997
 ```
 
 Run:
 
 ```bash
-npx -y -p @josephyan/qingflow-app-user-mcp@0.2.0-beta.995 qingflow-app-user-mcp
+npx -y -p @josephyan/qingflow-app-user-mcp@0.2.0-beta.997 qingflow-app-user-mcp
 ```
 
 Environment:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-app-user-mcp",
-  "version": "0.2.0-beta.995",
+  "version": "0.2.0-beta.997",
   "description": "Operational end-user MCP for Qingflow records, tasks, comments, and directory workflows.",
   "license": "MIT",
   "type": "module",

package/pyproject.toml

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

package/src/qingflow_mcp/__init__.py

@@ -5,7 +5,7 @@ from pathlib import Path
 
 __all__ = ["__version__"]
 
-_FALLBACK_VERSION = "0.2.0b995"
+_FALLBACK_VERSION = "0.2.0b997"
 
 
 def _resolve_local_pyproject_version() -> str | None:

package/src/qingflow_mcp/builder_facade/service.py

@@ -14419,6 +14419,8 @@ def _summarize_views(result: Any) -> list[dict[str, Any]]:
         view_type = _normalize_view_type_name(view.get("viewgraphType") or view.get("type"))
         columns = view.get("columnNames") or view.get("columns") or []
         group_by = view.get("groupBy") or view.get("group_by")
+        if not any((name, view_type, columns, group_by)) and str(view_key or "").isdigit():
+            continue
         if not any((name, view_key, view_type, columns, group_by)):
             continue
         items.append(
@@ -14461,11 +14463,24 @@ def _summarize_views_with_config(views_tool: ViewTools, *, profile: str, views:
             enriched_items.append(item)
             continue
         config = config_response.get("result") if isinstance(config_response.get("result"), dict) else {}
-        enriched_items.append(_merge_view_summary_with_config(item, config=config))
+        question_list: list[dict[str, Any]] = []
+        try:
+            question_response = views_tool.view_list_questions(profile=profile, viewgraph_key=view_key)
+            raw_question_list = question_response.get("result")
+            if isinstance(raw_question_list, list):
+                question_list = [deepcopy(entry) for entry in raw_question_list if isinstance(entry, dict)]
+        except (QingflowApiError, RuntimeError):
+            question_list = []
+        enriched_items.append(_merge_view_summary_with_config(item, config=config, question_list=question_list))
     return enriched_items, config_read_errors
 
 
-def _merge_view_summary_with_config(base: dict[str, Any], *, config: dict[str, Any]) -> dict[str, Any]:
+def _merge_view_summary_with_config(
+    base: dict[str, Any],
+    *,
+    config: dict[str, Any],
+    question_list: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
     summary = deepcopy(base)
     if not isinstance(config, dict) or not config:
         return summary
@@ -14473,6 +14488,7 @@ def _merge_view_summary_with_config(base: dict[str, Any], *, config: dict[str, A
         summary["visibility_summary"] = _visibility_summary(_public_visibility_from_member_auth(config.get("auth")))
     legacy_columns = [str(value) for value in (summary.get("columns") or []) if str(value or "").strip()]
     question_entries = _extract_view_question_entries(config.get("viewgraphQuestions"))
+    canonical_question_entries = _extract_view_question_entries(question_list)
     question_entries_by_id = {
         field_id: entry
         for entry in question_entries
@@ -14492,19 +14508,20 @@ def _merge_view_summary_with_config(base: dict[str, Any], *, config: dict[str, A
     display_entries = _sort_view_question_entries(
         [entry for entry in question_entries if bool(entry.get("visible", True))],
     )
+    public_display_entries = _filter_public_view_display_entries(display_entries, configured_column_ids=configured_column_ids)
     display_column_ids = [
         field_id
-        for field_id in (_coerce_nonnegative_int(entry.get("field_id")) for entry in display_entries)
+        for field_id in (_coerce_nonnegative_int(entry.get("field_id")) for entry in public_display_entries)
         if field_id is not None
     ]
     display_columns = [
         str(entry.get("name") or "").strip()
-        for entry in display_entries
+        for entry in public_display_entries
         if str(entry.get("name") or "").strip()
     ]
     apply_entries = [
         entry
-        for entry in display_entries
+        for entry in public_display_entries
         if _coerce_nonnegative_int(entry.get("field_id")) is not None
         and str(entry.get("name") or "").strip()
         and str(entry.get("name") or "").strip() not in _KNOWN_SYSTEM_VIEW_COLUMNS
@@ -14551,8 +14568,42 @@ def _merge_view_summary_with_config(base: dict[str, Any], *, config: dict[str, A
         summary["apply_columns"] = apply_columns
         summary["apply_column_ids"] = apply_column_ids
         config_enriched = True
-    if question_entries:
-        summary["column_details"] = display_entries or _sort_view_question_entries(question_entries)
+    if canonical_question_entries:
+        canonical_display_entries = _sort_view_question_entries(canonical_question_entries)
+        canonical_display_column_ids = [
+            field_id
+            for field_id in (_coerce_nonnegative_int(entry.get("field_id")) for entry in canonical_display_entries)
+            if field_id is not None
+        ]
+        canonical_display_columns = [
+            str(entry.get("name") or "").strip()
+            for entry in canonical_display_entries
+            if str(entry.get("name") or "").strip()
+        ]
+        canonical_apply_entries = [
+            entry
+            for entry in canonical_display_entries
+            if _coerce_nonnegative_int(entry.get("field_id")) is not None
+            and str(entry.get("name") or "").strip()
+            and str(entry.get("name") or "").strip() not in _KNOWN_SYSTEM_VIEW_COLUMNS
+        ]
+        summary["columns"] = canonical_display_columns
+        summary["display_columns"] = canonical_display_columns
+        summary["display_column_ids"] = canonical_display_column_ids
+        summary["column_details"] = canonical_display_entries
+        summary["apply_columns"] = [
+            str(entry.get("name") or "").strip()
+            for entry in canonical_apply_entries
+            if str(entry.get("name") or "").strip()
+        ]
+        summary["apply_column_ids"] = [
+            field_id
+            for field_id in (_coerce_nonnegative_int(entry.get("field_id")) for entry in canonical_apply_entries)
+            if field_id is not None
+        ]
+        config_enriched = True
+    elif question_entries:
+        summary["column_details"] = public_display_entries or _sort_view_question_entries(question_entries)
         config_enriched = True
     display_config = _extract_view_display_config(
         config,
@@ -14577,7 +14628,7 @@ def _merge_view_summary_with_config(base: dict[str, Any], *, config: dict[str, A
         summary["button_read_source"] = button_source
         config_enriched = True
     if config_enriched:
-        summary["read_source"] = "view_config"
+        summary["read_source"] = "view_config+question" if canonical_question_entries else "view_config"
     return summary
 
 
@@ -14585,29 +14636,64 @@ def _extract_view_question_entries(questions: Any) -> list[dict[str, Any]]:
     if not isinstance(questions, list):
         return []
     entries: list[dict[str, Any]] = []
-    for index, item in enumerate(questions, start=1):
-        if not isinstance(item, dict):
-            continue
-        field_id = _coerce_nonnegative_int(item.get("queId"))
-        name = str(item.get("queTitle") or "").strip() or None
-        visible_raw = item.get("beingListDisplay")
-        if visible_raw is None:
-            visible_raw = item.get("beingVisible")
-        visible = bool(visible_raw) if visible_raw is not None else True
-        display_order = _coerce_positive_int(item.get("displayOrdinal"))
-        entry: dict[str, Any] = {
-            "field_id": field_id,
-            "name": name,
-            "visible": visible,
-            "display_order": display_order if display_order is not None else index,
-        }
-        width = _coerce_positive_int(item.get("width"))
-        if width is not None:
-            entry["width"] = width
-        entries.append(entry)
+    fallback_order = 0
+
+    def walk(nodes: Any) -> None:
+        nonlocal fallback_order
+        if not isinstance(nodes, list):
+            return
+        for item in nodes:
+            if not isinstance(item, dict):
+                continue
+            children: list[Any] = []
+            for child_key in ("innerQues", "subQues", "innerQuestions", "subQuestions"):
+                child_value = item.get(child_key)
+                if isinstance(child_value, list) and child_value:
+                    children.extend(child_value)
+            if children:
+                walk(children)
+                continue
+            field_id = _coerce_nonnegative_int(item.get("queId"))
+            name = str(item.get("queTitle") or "").strip() or None
+            if field_id is None and name is None:
+                continue
+            visible_raw = item.get("beingListDisplay")
+            if visible_raw is None:
+                visible_raw = item.get("beingVisible")
+            visible = bool(visible_raw) if visible_raw is not None else True
+            display_order = _coerce_positive_int(item.get("displayOrdinal"))
+            fallback_order += 1
+            entry: dict[str, Any] = {
+                "field_id": field_id,
+                "name": name,
+                "visible": visible,
+                "display_order": display_order if display_order is not None else fallback_order,
+            }
+            width = _coerce_positive_int(item.get("width"))
+            if width is not None:
+                entry["width"] = width
+            entries.append(entry)
+
+    walk(questions)
     return entries
 
 
+def _filter_public_view_display_entries(
+    entries: list[dict[str, Any]],
+    *,
+    configured_column_ids: list[int],
+) -> list[dict[str, Any]]:
+    configured_set = set(configured_column_ids)
+    filtered: list[dict[str, Any]] = []
+    for entry in entries:
+        name = str(entry.get("name") or "").strip()
+        field_id = _coerce_nonnegative_int(entry.get("field_id"))
+        if name in _KNOWN_SYSTEM_VIEW_COLUMNS and field_id not in configured_set:
+            continue
+        filtered.append(entry)
+    return filtered or entries
+
+
 def _sort_view_question_entries(entries: list[dict[str, Any]]) -> list[dict[str, Any]]:
     return sorted(
         entries,

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

@@ -40,7 +40,11 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     action.add_argument("--action", required=True)
     action.add_argument("--payload-file")
     action.add_argument("--fields-file")
-    action.set_defaults(handler=_handle_action, format_hint="")
+    action.set_defaults(
+        handler=_handle_action,
+        format_hint="task_action_execute",
+        hide_effective_context_line=True,
+    )
 
     report = task_subparsers.add_parser("report", help="读取待办关联报表详情；推荐直接传 --task-id")
     report.add_argument("--task-id")

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

@@ -19,6 +19,10 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     get_parser.add_argument("--ws-id", type=int, default=0)
     get_parser.set_defaults(handler=_handle_get, format_hint="workspace_get")
 
+    select_parser = workspace_subparsers.add_parser("select", help="切换当前工作区")
+    select_parser.add_argument("--ws-id", type=int, required=True)
+    select_parser.set_defaults(handler=_handle_select, format_hint="workspace_get")
+
 
 def _handle_list(args: argparse.Namespace, context: CliContext) -> dict:
     return context.workspace.workspace_list(
@@ -34,3 +38,10 @@ def _handle_get(args: argparse.Namespace, context: CliContext) -> dict:
         profile=args.profile,
         ws_id=args.ws_id if int(args.ws_id or 0) > 0 else None,
     )
+
+
+def _handle_select(args: argparse.Namespace, context: CliContext) -> dict:
+    return context.workspace.workspace_select(
+        profile=args.profile,
+        ws_id=int(args.ws_id),
+    )

package/src/qingflow_mcp/cli/formatters.py

@@ -249,6 +249,30 @@ def _format_task_get(result: dict[str, Any]) -> str:
     return "\n".join(lines) + "\n"
 
 
+def _format_task_action(result: dict[str, Any]) -> str:
+    data = result.get("data") if isinstance(result.get("data"), dict) else {}
+    action = str(data.get("action") or "").strip().lower()
+    status = str(result.get("status") or "").strip().lower()
+
+    if status == "failed" or result.get("ok") is False:
+        lines = [_task_action_failure_label(action)]
+        reason = _task_action_failure_reason(result)
+        if reason:
+            lines.append(f"原因：{reason}")
+        debug_lines = _task_action_debug_lines(result)
+        if debug_lines:
+            lines.append("调试信息：")
+            lines.extend(f"- {line}" for line in debug_lines)
+        return "\n".join(lines) + "\n"
+
+    if status == "partial_success":
+        lines = [_task_action_success_label(action)]
+        lines.append(f"说明：{_task_action_partial_success_message(result)}")
+        return "\n".join(lines) + "\n"
+
+    return _task_action_success_label(action) + "\n"
+
+
 def _format_task_associated_report_detail(result: dict[str, Any]) -> str:
     data = result.get("data") if isinstance(result.get("data"), dict) else {}
     selection = data.get("selection") if isinstance(data.get("selection"), dict) else {}
@@ -416,6 +440,121 @@ def _first_present(payload: dict[str, Any], *keys: str) -> Any:
     return None
 
 
+def _task_action_success_label(action: str) -> str:
+    return {
+        "approve": "已通过",
+        "reject": "已驳回",
+        "rollback": "已退回",
+        "transfer": "已转交",
+        "save_only": "已保存",
+        "urge": "已催办",
+    }.get(action, "已执行")
+
+
+def _task_action_failure_label(action: str) -> str:
+    return {
+        "approve": "审批失败",
+        "reject": "驳回失败",
+        "rollback": "退回失败",
+        "transfer": "转交失败",
+        "save_only": "保存失败",
+        "urge": "催办失败",
+    }.get(action, "执行失败")
+
+
+def _task_action_partial_success_message(result: dict[str, Any]) -> str:
+    error_code = str(result.get("error_code") or "").strip().upper()
+    if error_code == "WORKFLOW_CONTINUATION_UNVERIFIED":
+        return "动作已提交，但暂未完成后续流程验证。可使用 --json 查看详细信息。"
+    if error_code == "TASK_ALREADY_PROCESSED":
+        return "当前待办已不可操作，系统判断流程可能已被其他人处理。可使用 --json 查看详细信息。"
+    warnings = result.get("warnings")
+    if isinstance(warnings, list):
+        for warning in warnings:
+            if not isinstance(warning, dict):
+                continue
+            code = str(warning.get("code") or "").strip().upper()
+            if code == "TASK_ALREADY_PROCESSED_UNCONFIRMED_ACTOR":
+                return "当前待办已不可操作，系统判断流程可能已被其他人处理。可使用 --json 查看详细信息。"
+            if code == "WORKFLOW_CONTINUATION_UNVERIFIED":
+                return "动作已提交，但暂未完成后续流程验证。可使用 --json 查看详细信息。"
+    return "动作已提交，但结果验证不完整。可使用 --json 查看详细信息。"
+
+
+def _task_action_failure_reason(result: dict[str, Any]) -> str | None:
+    error_code = str(result.get("error_code") or "").strip().upper()
+    mapped_error = {
+        "TASK_CONTEXT_VISIBILITY_UNVERIFIED": "当前待办已不可操作，且系统未能确认是否已被处理。",
+        "TASK_SAVE_ONLY_VERIFICATION_FAILED": "保存请求已发送，但未能确认字段是否全部保存成功。",
+        "WORKFLOW_CONTINUATION_UNVERIFIED": "动作已提交，但暂未验证到流程继续推进。",
+        "TASK_ALREADY_PROCESSED": "当前待办已不可操作，系统判断流程可能已被其他人处理。",
+    }.get(error_code)
+    if mapped_error:
+        return mapped_error
+
+    warnings = result.get("warnings")
+    if isinstance(warnings, list):
+        for warning in warnings:
+            if isinstance(warning, dict) and warning.get("message"):
+                return str(warning.get("message"))
+
+    data = result.get("data") if isinstance(result.get("data"), dict) else {}
+    transport_error = data.get("transport_error") if isinstance(data.get("transport_error"), dict) else {}
+    backend_code = transport_error.get("backend_code")
+    http_status = transport_error.get("http_status")
+    if backend_code not in (None, ""):
+        return f"后端返回错误码 {backend_code}。"
+    if http_status not in (None, ""):
+        return f"请求返回 HTTP {http_status}。"
+
+    verification = result.get("verification") if isinstance(result.get("verification"), dict) else {}
+    record_state_error = verification.get("record_state_error") if isinstance(verification.get("record_state_error"), dict) else {}
+    backend_code = record_state_error.get("backend_code")
+    http_status = record_state_error.get("http_status")
+    if backend_code not in (None, ""):
+        return f"后端返回错误码 {backend_code}。"
+    if http_status not in (None, ""):
+        return f"请求返回 HTTP {http_status}。"
+    if error_code:
+        return f"错误码：{error_code}"
+    return None
+
+
+def _task_action_debug_lines(result: dict[str, Any]) -> list[str]:
+    lines: list[str] = []
+    error_code = result.get("error_code")
+    if error_code not in (None, ""):
+        lines.append(f"error_code: {error_code}")
+
+    data = result.get("data") if isinstance(result.get("data"), dict) else {}
+    transport_error = data.get("transport_error") if isinstance(data.get("transport_error"), dict) else {}
+    for key in ("backend_code", "http_status", "category"):
+        value = transport_error.get(key)
+        if value not in (None, ""):
+            lines.append(f"{key}: {value}")
+
+    verification = result.get("verification") if isinstance(result.get("verification"), dict) else {}
+    for key in (
+        "runtime_continuation_verified",
+        "task_context_visibility_verified",
+        "fields_saved_verified",
+        "task_still_actionable",
+        "workflow_not_advanced",
+        "record_state_readable",
+    ):
+        if key in verification and verification.get(key) is not None:
+            lines.append(f"{key}: {verification.get(key)}")
+
+    record_state_error = verification.get("record_state_error") if isinstance(verification.get("record_state_error"), dict) else {}
+    for key in ("backend_code", "http_status", "category"):
+        value = record_state_error.get(key)
+        if value not in (None, ""):
+            entry = f"record_state_{key}: {value}"
+            if entry not in lines:
+                lines.append(entry)
+    return lines
+
+
 _FORMATTERS = {
     "auth_whoami": _format_whoami,
     "workspace_list": _format_workspace_list,
@@ -426,6 +565,7 @@ _FORMATTERS = {
     "record_list": _format_record_list,
     "task_list": _format_task_list,
     "task_get": _format_task_get,
+    "task_action_execute": _format_task_action,
     "task_associated_report_detail_get": _format_task_associated_report_detail,
     "import_verify": _format_import_verify,
     "import_status": _format_import_status,

package/src/qingflow_mcp/cli/main.py

@@ -152,6 +152,7 @@ def _emit_cli_effective_context_notice(args: argparse.Namespace, context: CliCon
     spec = cli_public_tool_spec_from_namespace(args)
     if spec is None or not spec.cli_show_effective_context:
         return
+    hide_context_line = bool(getattr(args, "hide_effective_context_line", False))
     sessions = getattr(context, "sessions", None)
     if sessions is None or not hasattr(sessions, "get_profile"):
         return
@@ -168,9 +169,13 @@ def _emit_cli_effective_context_notice(args: argparse.Namespace, context: CliCon
         workspace_label = f"{workspace_name} ({workspace_id})"
     else:
         workspace_label = str(workspace_id)
-    lines = [f"Context: profile={profile_name} workspace={workspace_label}"]
+    lines: list[str] = []
+    if not hide_context_line:
+        lines.append(f"Context: profile={profile_name} workspace={workspace_label}")
     if spec.cli_context_write and profile_name == "default":
         lines.append("Warning: using default profile for a workspace-sensitive write command")
+    if not lines:
+        return
     stream.write("\n".join(lines) + "\n")
 
 

package/src/qingflow_mcp/public_surface.py

@@ -36,6 +36,7 @@ USER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(USER_DOMAIN, "auth_logout", ("auth_logout",), ("auth", "logout")),
     PublicToolSpec(USER_DOMAIN, "workspace_list", ("workspace_list",), ("workspace", "list")),
     PublicToolSpec(USER_DOMAIN, "workspace_get", ("workspace_get",), ("workspace", "get")),
+    PublicToolSpec(USER_DOMAIN, "workspace_select", ("workspace_select",), ("workspace", "select")),
     PublicToolSpec(USER_DOMAIN, "app_list", ("app_list",), ("app", "list"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "app_search", ("app_search",), ("app", "search"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "app_get", ("app_get",), ("app", "get"), cli_show_effective_context=True),

package/src/qingflow_mcp/response_trim.py

@@ -737,7 +737,7 @@ def _register_policy(domains: tuple[str, ...], names: tuple[str, ...], transform
 _register_policy((USER_DOMAIN, BUILDER_DOMAIN), ("auth_use_credential", "auth_whoami"), _trim_auth_payload)
 _register_policy((USER_DOMAIN, BUILDER_DOMAIN), ("auth_logout",), _trim_auth_logout)
 _register_policy((USER_DOMAIN, BUILDER_DOMAIN), ("workspace_list",), _trim_workspace_list)
-_register_policy((USER_DOMAIN, BUILDER_DOMAIN), ("workspace_get",), _trim_workspace_get)
+_register_policy((USER_DOMAIN, BUILDER_DOMAIN), ("workspace_get", "workspace_select"), _trim_workspace_get)
 _register_policy((USER_DOMAIN,), ("app_list", "app_search"), _trim_app_search_like)
 _register_policy((USER_DOMAIN, BUILDER_DOMAIN), ("app_get",), _trim_app_get)
 _register_policy((BUILDER_DOMAIN,), ("app_repair_code_blocks",), _trim_builder_list_like)

package/src/qingflow_mcp/server_app_user.py

@@ -242,6 +242,16 @@ If the current MCP capability is unsupported, the workflow is awkward, or the us
             ws_id=ws_id,
         )
 
+    @server.tool()
+    def workspace_select(
+        profile: str = DEFAULT_PROFILE,
+        ws_id: int = 0,
+    ) -> dict:
+        return workspace.workspace_select(
+            profile=profile,
+            ws_id=ws_id,
+        )
+
     @server.tool()
     def app_list(profile: str = DEFAULT_PROFILE) -> dict:
         return apps.app_list(profile=profile)

package/src/qingflow_mcp/tools/app_tools.py

@@ -729,6 +729,7 @@ class AppTools(ToolBase):
         tag_ids = item.get("tagIds") if isinstance(item.get("tagIds"), list) else []
         compact = {
             "app_key": app_key,
+            "app_name": title,
             "title": title,
             "form_id": item.get("formId"),
             "tag_id": package_tag_id,

package/src/qingflow_mcp/tools/resource_read_tools.py

@@ -7,7 +7,6 @@ from ..errors import QingflowApiError, raise_tool_error
 from ..json_types import JSONObject
 from ..list_type_labels import SYSTEM_VIEW_DEFINITIONS
 from .app_tools import _analysis_supported_for_view_type
-from .app_tools import AppTools
 from .base import ToolBase, tool_cn_name
 from .qingbi_report_tools import QingbiReportTools
 
@@ -25,7 +24,6 @@ class ResourceReadTools(ToolBase):
     def __init__(self, sessions, backend) -> None:
         """执行内部辅助逻辑。"""
         super().__init__(sessions, backend)
-        self.apps = AppTools(sessions, backend)
         self.charts = QingbiReportTools(sessions, backend)
 
     @tool_cn_name("资源读取-门户列表")
@@ -153,9 +151,11 @@ class ResourceReadTools(ToolBase):
                 or str(config.get("viewgraphType") or config.get("viewType") or "").strip()
             )
             resolved_app_key = str(base_info.get("appKey") or config.get("appKey") or "").strip() or None
+            if not resolved_app_key:
+                resolved_app_key = self._resolve_app_key_from_view_form(context=context, view_key=view_key)
             if not resolved_app_key:
                 resolved_app_key = self._resolve_app_key_from_form_id(
-                    profile=profile,
+                    context=context,
                     form_id=_coerce_positive_int(base_info.get("formId") or config.get("formId")),
                 )
             if not resolved_app_key:
@@ -198,25 +198,56 @@ class ResourceReadTools(ToolBase):
 
         def runner(session_profile, _context):
             base = self.charts.qingbi_report_get_base(profile=profile, chart_id=chart_id).get("result") or {}
-            data = self.charts.qingbi_report_get_data(profile=profile, chart_id=chart_id, payload={}).get("result") or {}
-            data_config = data.get("config") if isinstance(data, dict) and isinstance(data.get("config"), dict) else {}
+            warnings: list[JSONObject] = []
+            verification = {
+                "chart_exists": True,
+                "chart_data_loaded": False,
+                "chart_config_loaded": False,
+            }
+            data: Any = None
+            data_config: dict[str, Any] = {}
+            try:
+                data = self.charts.qingbi_report_get_data(profile=profile, chart_id=chart_id, payload={}).get("result") or {}
+                verification["chart_data_loaded"] = True
+                if isinstance(data, dict) and isinstance(data.get("config"), dict):
+                    data_config = deepcopy(data.get("config"))
+                    verification["chart_config_loaded"] = True
+            except (QingflowApiError, RuntimeError) as error:
+                api_error = error if isinstance(error, QingflowApiError) else None
+                warnings.append(
+                    {
+                        "code": "CHART_DATA_UNAVAILABLE",
+                        "message": "chart_get could not load chart data; returning chart metadata and config when available.",
+                        "backend_code": api_error.backend_code if api_error is not None else None,
+                        "http_status": api_error.http_status if api_error is not None else None,
+                    }
+                )
+            if not data_config:
+                try:
+                    config_result = self.charts.qingbi_report_get_config(profile=profile, chart_id=chart_id).get("result") or {}
+                except (QingflowApiError, RuntimeError):
+                    config_result = {}
+                if isinstance(config_result, dict) and config_result:
+                    data_config = deepcopy(config_result)
+                    verification["chart_config_loaded"] = True
+            data_payload: dict[str, Any] = {
+                "chart_id": chart_id,
+                "chart_name": str(base.get("chartName") or base.get("name") or chart_id).strip() or chart_id,
+                "chart_type": str(base.get("chartType") or data_config.get("chartType") or "").strip() or None,
+                "data_source_type": str(base.get("dataSourceType") or "").strip() or None,
+                "data_source_id": str(base.get("dataSourceId") or "").strip() or None,
+            }
+            if verification["chart_data_loaded"]:
+                data_payload["data"] = deepcopy(data) if isinstance(data, dict) else {"value": data}
+            if data_config and not verification["chart_data_loaded"]:
+                data_payload["config"] = deepcopy(data_config)
             return {
                 "profile": profile,
                 "ws_id": session_profile.selected_ws_id,
                 "ok": True,
-                "warnings": [],
-                "verification": {
-                    "chart_exists": True,
-                    "chart_data_loaded": True,
-                },
-                "data": {
-                    "chart_id": chart_id,
-                    "chart_name": str(base.get("chartName") or base.get("name") or chart_id).strip() or chart_id,
-                    "chart_type": str(base.get("chartType") or data_config.get("chartType") or "").strip() or None,
-                    "data_source_type": str(base.get("dataSourceType") or "").strip() or None,
-                    "data_source_id": str(base.get("dataSourceId") or "").strip() or None,
-                    "data": deepcopy(data) if isinstance(data, dict) else {"value": data},
-                },
+                "warnings": warnings,
+                "verification": verification,
+                "data": data_payload,
             }
 
         return self._run(profile, runner)
@@ -236,25 +267,54 @@ class ResourceReadTools(ToolBase):
         if not chart_id:
             raise_tool_error(QingflowApiError.config_error("chart_id is required"))
 
-    def _resolve_app_key_from_form_id(self, *, profile: str, form_id: int | None) -> str | None:
+    def _resolve_app_key_from_view_form(self, *, context: Any, view_key: str) -> str | None:
+        try:
+            form_payload = self.backend.request("GET", context, f"/view/{view_key}/form")
+        except QingflowApiError:
+            return None
+        if not isinstance(form_payload, dict):
+            return None
+        app_key = str(form_payload.get("appKey") or "").strip()
+        return app_key or None
+
+    def _resolve_app_key_from_form_id(self, *, context: Any, form_id: int | None) -> str | None:
         """执行内部辅助逻辑。"""
         if form_id is None:
             return None
         try:
-            payload = self.apps.app_list(profile=profile)
+            payload = self.backend.request("GET", context, "/tag/apps")
         except QingflowApiError:
-            return None
-        items = payload.get("items")
-        if not isinstance(items, list):
-            return None
-        for item in items:
-            if not isinstance(item, dict):
-                continue
-            if _coerce_positive_int(item.get("form_id")) != form_id:
-                continue
-            app_key = str(item.get("app_key") or "").strip()
-            if app_key:
-                return app_key
+            payload = None
+        app_key = _find_visible_app_key_by_form_id(payload, form_id=form_id)
+        if app_key:
+            return app_key
+        page_num = 1
+        page_size = 200
+        while page_num <= 20:
+            try:
+                page = self.backend.request(
+                    "GET",
+                    context,
+                    "/app/item",
+                    params={"pageNum": page_num, "pageSize": page_size},
+                )
+            except QingflowApiError:
+                return None
+            items = page.get("list") if isinstance(page, dict) else []
+            if not isinstance(items, list) or not items:
+                return None
+            for item in items:
+                if not isinstance(item, dict):
+                    continue
+                if _coerce_positive_int(item.get("formId") or item.get("form_id")) != form_id:
+                    continue
+                app_key = str(item.get("appKey") or item.get("app_key") or "").strip()
+                if app_key:
+                    return app_key
+            total = _coerce_positive_int(page.get("total")) if isinstance(page, dict) else None
+            if total is not None and page_num * page_size >= total:
+                break
+            page_num += 1
         return None
 
 
@@ -419,3 +479,25 @@ def _coerce_positive_int(value: Any) -> int | None:
     except (TypeError, ValueError):
         return None
     return number if number > 0 else None
+
+
+def _find_visible_app_key_by_form_id(payload: Any, *, form_id: int) -> str | None:
+    if isinstance(payload, list):
+        for item in payload:
+            resolved = _find_visible_app_key_by_form_id(item, form_id=form_id)
+            if resolved:
+                return resolved
+        return None
+    if not isinstance(payload, dict):
+        return None
+    candidate_form_id = _coerce_positive_int(payload.get("formId") or payload.get("form_id"))
+    if candidate_form_id == form_id:
+        app_key = str(payload.get("appKey") or payload.get("app_key") or "").strip()
+        if app_key:
+            return app_key
+    for value in payload.values():
+        if isinstance(value, (list, dict)):
+            resolved = _find_visible_app_key_by_form_id(value, form_id=form_id)
+            if resolved:
+                return resolved
+    return None

package/src/qingflow_mcp/tools/task_context_tools.py

@@ -54,6 +54,7 @@ class TaskContextTools(ToolBase):
         self._task_tools = TaskTools(sessions, backend)
         self._approval_tools = ApprovalTools(sessions, backend)
         self._record_tools = RecordTools(sessions, backend)
+        self._app_name_cache: dict[str, str | None] = {}
 
     def register(self, mcp: FastMCP) -> None:
         """注册当前工具到 MCP 服务。"""
@@ -1586,7 +1587,7 @@ class TaskContextTools(ToolBase):
             f"/app/{app_key}/apply/{record_id}",
             params={"role": 3, "listType": 1, "auditNodeId": workflow_node_id},
         )
-        app_name = self._task_app_name(detail, node_info)
+        app_name = self._task_app_name(context=context, app_key=app_key, detail=detail, node_info=node_info)
         associated_report_visible = self._resolve_associated_report_visible(node_info, detail)
         associated_reports = {"visible": associated_report_visible, "loaded": False, "count": 0, "items": []}
         if include_associated_reports and associated_report_visible:
@@ -1833,12 +1834,82 @@ class TaskContextTools(ToolBase):
         }
         return {key: value for key, value in compact.items() if value not in (None, "", [])} or None
 
-    def _task_app_name(self, detail: dict[str, Any], node_info: dict[str, Any]) -> Any:
+    def _task_app_name(
+        self,
+        *,
+        context: BackendRequestContext,
+        app_key: str,
+        detail: dict[str, Any],
+        node_info: dict[str, Any],
+    ) -> Any:
         for source in (detail, node_info):
             for key in ("formTitle", "appName", "worksheetName", "appTitle"):
                 value = source.get(key)
                 if value not in (None, ""):
+                    if app_key:
+                        self._app_name_cache[app_key] = str(value)
+                    return value
+        normalized_app_key = str(app_key or "").strip()
+        if not normalized_app_key:
+            return None
+        if normalized_app_key in self._app_name_cache:
+            return self._app_name_cache[normalized_app_key]
+        resolved = self._resolve_task_app_name_from_base_info(context=context, app_key=normalized_app_key)
+        if resolved is None:
+            resolved = self._resolve_task_app_name_from_visible_apps(context=context, app_key=normalized_app_key)
+        self._app_name_cache[normalized_app_key] = resolved
+        return resolved
+
+    def _resolve_task_app_name_from_base_info(
+        self,
+        *,
+        context: BackendRequestContext,
+        app_key: str,
+    ) -> str | None:
+        try:
+            base_info = self.backend.request("GET", context, f"/app/{app_key}/baseInfo")
+        except QingflowApiError:
+            return None
+        if not isinstance(base_info, dict):
+            return None
+        for key in ("formTitle", "title", "appName", "name"):
+            value = str(base_info.get(key) or "").strip()
+            if value:
+                return value
+        return None
+
+    def _resolve_task_app_name_from_visible_apps(
+        self,
+        *,
+        context: BackendRequestContext,
+        app_key: str,
+    ) -> str | None:
+        try:
+            visible_apps = self.backend.request("GET", context, "/tag/apps")
+        except QingflowApiError:
+            return None
+        return self._find_task_app_name_in_visible_apps(visible_apps, app_key=app_key)
+
+    def _find_task_app_name_in_visible_apps(self, payload: Any, *, app_key: str) -> str | None:
+        if isinstance(payload, list):
+            for item in payload:
+                resolved = self._find_task_app_name_in_visible_apps(item, app_key=app_key)
+                if resolved:
+                    return resolved
+            return None
+        if not isinstance(payload, dict):
+            return None
+        candidate_app_key = str(payload.get("appKey") or payload.get("app_key") or "").strip()
+        if candidate_app_key == app_key:
+            for key in ("formTitle", "title", "appName", "name"):
+                value = str(payload.get(key) or "").strip()
+                if value:
                     return value
+        for value in payload.values():
+            if isinstance(value, (list, dict)):
+                resolved = self._find_task_app_name_in_visible_apps(value, app_key=app_key)
+                if resolved:
+                    return resolved
         return None
 
     def _task_record_core_fields(self, answers: Any, *, limit: int = 12) -> dict[str, Any]:

package/src/qingflow_mcp/tools/workspace_tools.py

@@ -45,6 +45,16 @@ class WorkspaceTools(ToolBase):
                 ws_id=ws_id if ws_id > 0 else None,
             )
 
+        @mcp.tool()
+        def workspace_select(
+            profile: str = DEFAULT_PROFILE,
+            ws_id: int = 0,
+        ) -> dict[str, Any]:
+            return self.workspace_select(
+                profile=profile,
+                ws_id=ws_id,
+            )
+
         @mcp.tool()
         def workspace_set_plugin_status(
             profile: str = DEFAULT_PROFILE,
@@ -128,6 +138,43 @@ class WorkspaceTools(ToolBase):
 
         return self._run(profile, runner, require_workspace=False)
 
+    @tool_cn_name("切换工作区")
+    def workspace_select(
+        self,
+        *,
+        profile: str = DEFAULT_PROFILE,
+        ws_id: int,
+    ) -> dict[str, Any]:
+        """切换当前 profile 选中的工作区，并尽量同步真实 systemVersion。"""
+        if ws_id <= 0:
+            raise_tool_error(QingflowApiError.config_error("ws_id must be positive"))
+
+        def runner(_, context):
+            workspace = self._fetch_workspace_with_fallback(context, ws_id=ws_id)
+            workspace_name = str(workspace.get("workspaceName") or workspace.get("wsName") or workspace.get("remark") or "").strip() or None
+            selected = self.sessions.select_workspace(profile, ws_id=ws_id, ws_name=workspace_name)
+            system_version = self._workspace_system_version(workspace)
+            qf_version_source = "workspace_system_version" if system_version else "unverified"
+            if system_version:
+                selected = self.sessions.update_route(
+                    profile,
+                    qf_version=system_version,
+                    qf_version_source=qf_version_source,
+                )
+            return {
+                "profile": profile,
+                "ws_id": ws_id,
+                "qf_version": selected.qf_version,
+                "qf_version_source": selected.qf_version_source or qf_version_source,
+                "workspace": workspace,
+                "selected": {
+                    "ws_id": selected.selected_ws_id,
+                    "workspace_name": selected.selected_ws_name,
+                },
+            }
+
+        return self._run(profile, runner, require_workspace=False)
+
     @tool_cn_name("设置工作区插件状态")
     def workspace_set_plugin_status(
         self,