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

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

@@ -50,7 +50,7 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     member = builder_subparsers.add_parser("member", help="成员目录")
     member_subparsers = member.add_subparsers(dest="builder_member_command", required=True)
     member_search = member_subparsers.add_parser("search", help="搜索成员")
-    member_search.add_argument("--query", default="")
+    member_search.add_argument("--query", required=True)
     member_search.add_argument("--page-num", type=int, default=1)
     member_search.add_argument("--page-size", type=int, default=20)
     member_search.add_argument("--contain-disable", action=argparse.BooleanOptionalAction, default=False)
@@ -59,7 +59,7 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     role = builder_subparsers.add_parser("role", help="角色目录")
     role_subparsers = role.add_subparsers(dest="builder_role_command", required=True)
     role_search = role_subparsers.add_parser("search", help="搜索角色")
-    role_search.add_argument("--keyword", default="")
+    role_search.add_argument("--keyword", required=True)
     role_search.add_argument("--page-num", type=int, default=1)
     role_search.add_argument("--page-size", type=int, default=20)
     role_search.set_defaults(handler=_handle_role_search, format_hint="builder_summary")

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

@@ -12,7 +12,7 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
 
     start = export_subparsers.add_parser("start", help="启动导出")
     start.add_argument("--app-key", required=True)
-    start.add_argument("--view-id", default="system:all")
+    start.add_argument("--view-id", required=True)
     start.add_argument("--column", dest="columns", action="append", type=int, default=[], help="只导出这些 field_id；不传时导出当前视图全部字段")
     start.add_argument("--columns-file", help="JSON/YAML list，内容与 --column 语义一致")
     start.add_argument("--where-file", help="JSON/YAML list，内容与 record list 的 where DSL 一致；内部先查命中 record_id 再走原生导出")
@@ -33,7 +33,7 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
 
     direct = export_subparsers.add_parser("direct", help="直接导出并下载")
     direct.add_argument("--app-key", required=True)
-    direct.add_argument("--view-id", default="system:all")
+    direct.add_argument("--view-id", required=True)
     direct.add_argument("--column", dest="columns", action="append", type=int, default=[], help="只导出这些 field_id；不传时导出当前视图全部字段")
     direct.add_argument("--columns-file", help="JSON/YAML list，内容与 --column 语义一致")
     direct.add_argument("--where-file", help="JSON/YAML list，内容与 record list 的 where DSL 一致；内部先查命中 record_id 再走原生导出")

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

@@ -13,7 +13,7 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     template = import_subparsers.add_parser("template", help="下载导入模板")
     template.add_argument("--app-key", required=True)
     template.add_argument("--download-to-path")
-    template.set_defaults(handler=_handle_template, format_hint="")
+    template.set_defaults(handler=_handle_template, format_hint="import_template")
 
     verify = import_subparsers.add_parser("verify", help="校验导入文件")
     verify.add_argument("--app-key", required=True)

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

@@ -18,12 +18,20 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
 
     schema = record_subparsers.add_parser("schema", help="读取记录相关表结构")
     schema.add_argument("--mode", dest="legacy_mode", help=argparse.SUPPRESS)
-    schema_subparsers = schema.add_subparsers(dest="record_schema_command")
+    schema_subparsers = schema.add_subparsers(
+        dest="record_schema_command",
+        metavar="{browse,insert,update,import,code-block}",
+    )
     schema.set_defaults(handler=_handle_schema_root, format_hint="")
 
-    schema_applicant = schema_subparsers.add_parser("applicant", help="读取申请节点表结构")
+    schema_applicant = schema_subparsers.add_parser("applicant", help=argparse.SUPPRESS)
     schema_applicant.add_argument("--app-key", required=True)
     schema_applicant.set_defaults(handler=_handle_schema_applicant, format_hint="")
+    schema_subparsers._choices_actions = [  # type: ignore[attr-defined]
+        action
+        for action in schema_subparsers._choices_actions  # type: ignore[attr-defined]
+        if getattr(action, "dest", None) != "applicant"
+    ]
 
     schema_browse = schema_subparsers.add_parser("browse", help="读取浏览视图表结构")
     schema_browse.add_argument("--app-key", required=True)
@@ -37,6 +45,7 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     schema_update = schema_subparsers.add_parser("update", help="读取更新记录表结构")
     schema_update.add_argument("--app-key", required=True)
     schema_update.add_argument("--record-id", required=True)
+    schema_update.add_argument("--view-id")
     schema_update.set_defaults(handler=_handle_schema_update, format_hint="")
 
     schema_import = schema_subparsers.add_parser("import", help="读取导入表结构")
@@ -105,7 +114,7 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     logs = record_subparsers.add_parser("logs", help="读取单条记录全量日志并写入本地 JSONL")
     logs.add_argument("--app-key", required=True)
     logs.add_argument("--record-id", required=True)
-    logs.add_argument("--view-id")
+    logs.add_argument("--view-id", required=True)
     logs.set_defaults(handler=_handle_logs, format_hint="record_logs")
 
     insert = record_subparsers.add_parser("insert", help="新增记录")
@@ -113,22 +122,25 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     insert.add_argument("--fields-file", help=argparse.SUPPRESS)
     insert.add_argument("--items-file")
     insert.add_argument("--verify-write", action=argparse.BooleanOptionalAction, default=True)
-    insert.set_defaults(handler=_handle_insert, format_hint="")
+    insert.set_defaults(handler=_handle_insert, format_hint="record_write")
 
     update = record_subparsers.add_parser("update", help="更新记录")
     update.add_argument("--app-key", required=True)
     update.add_argument("--record-id")
     update.add_argument("--fields-file")
     update.add_argument("--items-file")
+    update.add_argument("--view-id")
     update.add_argument("--dry-run", action=argparse.BooleanOptionalAction, default=False)
     update.add_argument("--verify-write", action=argparse.BooleanOptionalAction, default=True)
-    update.set_defaults(handler=_handle_update, format_hint="")
+    update.set_defaults(handler=_handle_update, format_hint="record_write")
 
     delete = record_subparsers.add_parser("delete", help="删除记录")
     delete.add_argument("--app-key", required=True)
     delete.add_argument("--record-id")
     delete.add_argument("--record-ids-file")
-    delete.set_defaults(handler=_handle_delete, format_hint="")
+    delete.add_argument("--view-id")
+    delete.add_argument("--list-type", dest="legacy_list_type", type=int, help=argparse.SUPPRESS)
+    delete.set_defaults(handler=_handle_delete, format_hint="record_delete")
 
     analyze = record_subparsers.add_parser("analyze", help=argparse.SUPPRESS)
     record_subparsers._choices_actions = [  # type: ignore[attr-defined]
@@ -153,6 +165,7 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     code_block.add_argument("--app-key", required=True)
     code_block.add_argument("--record-id", required=True)
     code_block.add_argument("--code-block-field", required=True)
+    code_block.add_argument("--view-id")
     code_block.add_argument("--role", type=int, default=1)
     code_block.add_argument("--workflow-node-id", type=int)
     code_block.add_argument("--answers-file")
@@ -161,7 +174,7 @@ def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) ->
     code_block.add_argument("--apply-writeback", action=argparse.BooleanOptionalAction, default=True)
     code_block.add_argument("--verify-writeback", action=argparse.BooleanOptionalAction, default=True)
     code_block.add_argument("--force-refresh-form", action="store_true")
-    code_block.set_defaults(handler=_handle_code_block_run, format_hint="")
+    code_block.set_defaults(handler=_handle_code_block_run, format_hint="code_block_run")
 
 
 def _columns(args: argparse.Namespace) -> list[Any]:
@@ -182,20 +195,20 @@ def _handle_schema_root(args: argparse.Namespace, _context: CliContext) -> dict:
     mode = (args.legacy_mode or "").strip()
     if mode:
         replacement = {
-            "applicant": "record schema applicant --app-key APP_KEY",
+            "applicant": "record schema insert --app-key APP_KEY",
             "browse": "record schema browse --app-key APP_KEY --view-id VIEW_ID",
             "insert": "record schema insert --app-key APP_KEY",
-            "update": "record schema update --app-key APP_KEY --record-id RECORD_ID",
+            "update": "record schema update --app-key APP_KEY --record-id RECORD_ID [--view-id VIEW_ID]",
             "import": "record schema import --app-key APP_KEY",
             "code-block": "record schema code-block --app-key APP_KEY",
-        }.get(mode, "record schema <applicant|browse|insert|update|import|code-block> ...")
+        }.get(mode, "record schema <browse|insert|update|import|code-block> ...")
         raise_config_error(
             "record schema --mode is no longer accepted.",
             fix_hint=f"Use `{replacement}` instead.",
         )
     raise_config_error(
         "record schema requires an explicit subcommand.",
-        fix_hint="Use one of: `record schema applicant`, `record schema browse`, `record schema insert`, `record schema update`, `record schema import`, or `record schema code-block`.",
+        fix_hint="Use one of: `record schema browse`, `record schema insert`, `record schema update`, `record schema import`, or `record schema code-block`.",
     )
 
 
@@ -224,6 +237,7 @@ def _handle_schema_update(args: argparse.Namespace, context: CliContext) -> dict
         profile=args.profile,
         app_key=args.app_key,
         record_id=args.record_id,
+        view_id=args.view_id,
     )
 
 
@@ -382,6 +396,7 @@ def _handle_update(args: argparse.Namespace, context: CliContext) -> dict:
             record_id=None,
             fields=None,
             items=require_list_arg(args.items_file, option_name="--items-file"),
+            view_id=args.view_id,
             dry_run=bool(args.dry_run),
             verify_write=bool(args.verify_write),
         )
@@ -400,17 +415,29 @@ def _handle_update(args: argparse.Namespace, context: CliContext) -> dict:
         app_key=args.app_key,
         record_id=args.record_id,
         fields=require_object_arg(args.fields_file, option_name="--fields-file"),
+        view_id=args.view_id,
         verify_write=bool(args.verify_write),
     )
 
 
 def _handle_delete(args: argparse.Namespace, context: CliContext) -> dict:
+    if args.legacy_list_type is not None:
+        raise_config_error(
+            "record delete no longer accepts list_type.",
+            fix_hint="Call `app_get` first and pass an accessible system `view_id`, for example `--view-id system:all`.",
+        )
+    if not (args.view_id or "").strip():
+        raise_config_error(
+            "record delete requires --view-id.",
+            fix_hint="Use a system view_id from app get accessible_views, for example `--view-id system:all`; custom views are not supported for deletion.",
+        )
     record_ids = load_list_arg(args.record_ids_file, option_name="--record-ids-file")
     return context.record.record_delete_public(
         profile=args.profile,
         app_key=args.app_key,
         record_id=args.record_id,
         record_ids=record_ids,
+        view_id=args.view_id,
     )
 
 
@@ -446,6 +473,7 @@ def _handle_code_block_run(args: argparse.Namespace, context: CliContext) -> dic
         app_key=args.app_key,
         record_id=args.record_id,
         code_block_field=args.code_block_field,
+        view_id=args.view_id,
         role=args.role,
         workflow_node_id=args.workflow_node_id,
         answers=load_list_arg(args.answers_file, option_name="--answers-file"),

package/src/qingflow_mcp/cli/context.py

@@ -13,7 +13,6 @@ from ..tools.feedback_tools import FeedbackTools
 from ..tools.file_tools import FileTools
 from ..tools.import_tools import ImportTools
 from ..tools.record_tools import RecordTools
-from ..tools.repository_dev_tools import RepositoryDevTools
 from ..tools.resource_read_tools import ResourceReadTools
 from ..tools.task_context_tools import TaskContextTools
 from ..tools.workspace_tools import WorkspaceTools
@@ -35,7 +34,6 @@ class CliContext:
     files: FileTools
     builder_feedback: FeedbackTools
     builder: AiBuilderTools
-    repo: RepositoryDevTools
 
     def close(self) -> None:
         self.backend.close()
@@ -59,5 +57,4 @@ def build_cli_context() -> CliContext:
         files=FileTools(sessions, backend),
         builder_feedback=FeedbackTools(backend, mcp_side="App Builder MCP"),
         builder=AiBuilderTools(sessions, backend),
-        repo=RepositoryDevTools(sessions, backend),
     )

package/src/qingflow_mcp/cli/formatters.py

@@ -8,8 +8,11 @@ from typing import Any, TextIO
 def emit_text_result(result: dict[str, Any], *, hint: str, stream: TextIO) -> None:
     text = _format_cancelled_result(result)
     if text is None:
-        formatter = _FORMATTERS.get(hint, _format_generic)
-        text = formatter(result)
+        if _is_failed_result(result) and hint != "task_action_execute":
+            text = _format_failed_result(result)
+        else:
+            formatter = _FORMATTERS.get(hint, _format_generic)
+            text = formatter(result)
     stream.write(text)
     if not text.endswith("\n"):
         stream.write("\n")
@@ -21,6 +24,50 @@ def _format_cancelled_result(result: dict[str, Any]) -> str | None:
     return str(result.get("message") or "已取消") + "\n"
 
 
+def _is_failed_result(result: dict[str, Any]) -> bool:
+    if _is_executed_nonfatal_result(result):
+        return False
+    if result.get("ok") is False:
+        return True
+    return str(result.get("status") or "").lower() in {"failed", "blocked"}
+
+
+def _is_executed_nonfatal_result(result: dict[str, Any]) -> bool:
+    status = str(result.get("status") or "").lower()
+    executed = bool(
+        result.get("write_executed")
+        or result.get("delete_executed")
+        or result.get("action_executed")
+        or result.get("export_executed")
+    )
+    return executed and status in {"partial_success", "verification_failed", "running", "queued", "unknown"}
+
+
+def _format_failed_result(result: dict[str, Any]) -> str:
+    lines = [f"Status: {result.get('status') or 'failed'}"]
+    for key, label in (
+        ("error_code", "Error Code"),
+        ("message", "Message"),
+        ("backend_code", "Backend Code"),
+        ("request_id", "Request ID"),
+        ("http_status", "HTTP Status"),
+        ("category", "Category"),
+    ):
+        value = result.get(key)
+        if value not in (None, ""):
+            lines.append(f"{label}: {value}")
+
+    data = result.get("data") if isinstance(result.get("data"), dict) else {}
+    selection = data.get("selection") if isinstance(data.get("selection"), dict) else {}
+    if selection:
+        lines.append("Selection:")
+        lines.extend(f"- {line}" for line in _dict_scalar_lines(selection))
+
+    _append_warnings(lines, result.get("warnings"))
+    _append_verification(lines, result.get("verification"))
+    return "\n".join(lines) + "\n"
+
+
 def _format_generic(result: dict[str, Any]) -> str:
     lines: list[str] = []
     title = _first_present(result, "status", "message")
@@ -323,6 +370,116 @@ def _format_record_logs(result: dict[str, Any]) -> str:
     return "\n".join(lines) + "\n"
 
 
+def _format_record_write(result: dict[str, Any]) -> str:
+    status = str(result.get("status") or "").strip().lower()
+    write_executed = bool(result.get("write_executed"))
+    verification_status = str(result.get("verification_status") or "").strip().lower()
+    if write_executed and verification_status == "failed":
+        title = "写入已提交（回读验证未完成）"
+    elif write_executed and status in {"success", "completed"}:
+        title = "写入成功"
+    elif status:
+        title = status
+    else:
+        title = "写入结果"
+
+    lines = [title]
+    if result.get("record_id") not in (None, ""):
+        lines.append(f"Record ID: {result.get('record_id')}")
+    if result.get("apply_id") not in (None, "") and result.get("apply_id") != result.get("record_id"):
+        lines.append(f"Apply ID: {result.get('apply_id')}")
+
+    update_route = result.get("update_route") if isinstance(result.get("update_route"), dict) else {}
+    route_name = update_route.get("route") or update_route.get("type") or update_route.get("label")
+    if route_name:
+        lines.append(f"Update Route: {route_name}")
+
+    if verification_status:
+        lines.append(f"Verification: {verification_status}")
+    if write_executed:
+        lines.append("Safe To Retry: false")
+
+    if write_executed and verification_status == "failed":
+        verification = result.get("data", {}).get("verification") if isinstance(result.get("data"), dict) else None
+        if isinstance(verification, dict):
+            warning_codes = [
+                str(item.get("code"))
+                for item in verification.get("warnings", [])
+                if isinstance(item, dict) and item.get("code")
+            ]
+            if warning_codes:
+                lines.append("Verification Note: " + ", ".join(warning_codes[:3]))
+        lines.append("说明：写请求已执行；当前结果只表示后置回读未能确认字段值，不等同于写入被拒绝。")
+
+    _append_warnings(lines, result.get("warnings"))
+    return "\n".join(lines) + "\n"
+
+
+def _format_record_delete(result: dict[str, Any]) -> str:
+    status = str(result.get("status") or "").strip().lower()
+    deleted_ids = [str(item) for item in result.get("deleted_ids", []) if item not in (None, "")]
+    failed_ids = [str(item) for item in result.get("failed_ids", []) if item not in (None, "")]
+    write_executed = bool(result.get("write_executed"))
+
+    if deleted_ids and failed_ids:
+        title = "删除部分完成"
+    elif deleted_ids:
+        title = "删除完成"
+    elif status == "failed" or result.get("ok") is False:
+        title = "删除未执行"
+    else:
+        title = "删除结果"
+
+    lines = [title]
+    lines.append(f"Deleted: {len(deleted_ids)}")
+    if deleted_ids:
+        lines.append("Deleted IDs: " + ", ".join(deleted_ids[:20]))
+    lines.append(f"Failed: {len(failed_ids)}")
+    if failed_ids:
+        lines.append("Failed IDs: " + ", ".join(failed_ids[:20]))
+    if write_executed:
+        lines.append("Safe To Retry: false")
+    elif result.get("safe_to_retry") is not None:
+        lines.append(f"Safe To Retry: {str(bool(result.get('safe_to_retry'))).lower()}")
+    _append_warnings(lines, result.get("warnings"))
+    return "\n".join(lines) + "\n"
+
+
+def _format_code_block_run(result: dict[str, Any]) -> str:
+    status = str(result.get("status") or "").strip().lower()
+    execution = result.get("execution") if isinstance(result.get("execution"), dict) else {}
+    writeback = result.get("writeback") if isinstance(result.get("writeback"), dict) else {}
+    executed = bool(execution.get("executed"))
+    writeback_applied = bool(writeback.get("applied"))
+    write_verified = writeback.get("write_verified")
+
+    if executed and writeback_applied and status == "verification_failed":
+        title = "代码块已执行，回写已提交（验证未完成）"
+    elif executed and writeback_applied:
+        title = "代码块已执行，回写成功"
+    elif executed:
+        title = "代码块已执行"
+    elif status:
+        title = status
+    else:
+        title = "代码块结果"
+
+    lines = [title]
+    if result.get("record_id") not in (None, ""):
+        lines.append(f"Record ID: {result.get('record_id')}")
+    code_block_field = result.get("code_block_field") if isinstance(result.get("code_block_field"), dict) else {}
+    if code_block_field.get("title"):
+        lines.append(f"Code Block Field: {code_block_field.get('title')}")
+    if execution:
+        lines.append(f"Result Count: {execution.get('result_count', 0)}")
+    if writeback:
+        lines.append(f"Writeback: attempted={writeback.get('attempted')} applied={writeback_applied} verified={write_verified}")
+    if executed and writeback_applied and status == "verification_failed":
+        lines.append("说明：代码块执行和回写请求已完成；当前结果只表示后置回读未能确认字段值，不等同于回写被拒绝。")
+    _append_warnings(lines, result.get("warnings"))
+    return "\n".join(lines) + "\n"
+
+
 def _format_task_list(result: dict[str, Any]) -> str:
     data = result.get("data") if isinstance(result.get("data"), dict) else {}
     items = data.get("items") if isinstance(data.get("items"), list) else []
@@ -525,6 +682,42 @@ def _format_import_verify(result: dict[str, Any]) -> str:
     return "\n".join(lines) + "\n"
 
 
+def _format_import_template(result: dict[str, Any]) -> str:
+    verification = result.get("verification") if isinstance(result.get("verification"), dict) else {}
+    template_source = verification.get("template_source")
+    if not template_source:
+        template_source = "official" if result.get("template_url") else ("local_generated" if result.get("downloaded_to_path") else "unknown")
+    if result.get("downloaded_to_path"):
+        title = "导入模板已生成" if template_source == "local_generated" else "导入模板已下载"
+    elif result.get("template_url"):
+        title = "导入模板已获取"
+    else:
+        title = "导入模板结果"
+
+    lines = [
+        title,
+        f"App Key: {result.get('app_key') or '-'}",
+        f"Template Source: {template_source}",
+    ]
+    if result.get("downloaded_to_path"):
+        lines.append(f"Local Path: {result.get('downloaded_to_path')}")
+    if result.get("template_url"):
+        lines.append(f"Template URL: {result.get('template_url')}")
+    import_capability = result.get("import_capability") if isinstance(result.get("import_capability"), dict) else {}
+    if import_capability:
+        lines.append(
+            "Import Capability: "
+            f"{import_capability.get('auth_source') or 'unknown'} / "
+            f"can_import={import_capability.get('can_import')}"
+        )
+    expected_columns = result.get("expected_columns") if isinstance(result.get("expected_columns"), list) else []
+    if expected_columns:
+        lines.append(f"Columns: {len(expected_columns)}")
+    _append_warnings(lines, result.get("warnings"))
+    _append_verification(lines, result.get("verification"))
+    return "\n".join(lines) + "\n"
+
+
 def _format_import_status(result: dict[str, Any]) -> str:
     lines = [
         f"Status: {result.get('status') or '-'}",
@@ -721,21 +914,23 @@ def _task_action_failure_label(action: str) -> str:
 
 
 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_ACTION_VERIFICATION_PERMISSION_UNAVAILABLE":
+                return "动作已提交；后置验证读取受当前权限限制，不能据此判断动作被拒绝。可使用 --json 查看详细信息。"
             if code == "TASK_ALREADY_PROCESSED_UNCONFIRMED_ACTOR":
                 return "当前待办已不可操作，系统判断流程可能已被其他人处理。可使用 --json 查看详细信息。"
             if code == "WORKFLOW_CONTINUATION_UNVERIFIED":
                 return "动作已提交，但暂未完成后续流程验证。可使用 --json 查看详细信息。"
+    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 查看详细信息。"
     return "动作已提交，但结果验证不完整。可使用 --json 查看详细信息。"
 
 
@@ -824,11 +1019,15 @@ _FORMATTERS = {
     "record_access": _format_record_access,
     "record_get": _format_record_get,
     "record_logs": _format_record_logs,
+    "record_write": _format_record_write,
+    "record_delete": _format_record_delete,
+    "code_block_run": _format_code_block_run,
     "task_list": _format_task_list,
     "task_workbench": _format_task_workbench,
     "task_get": _format_task_get,
     "task_action_execute": _format_task_action,
     "task_associated_report_detail_get": _format_task_associated_report_detail,
+    "import_template": _format_import_template,
     "import_verify": _format_import_verify,
     "import_status": _format_import_status,
     "export_start": _format_export_start,

package/src/qingflow_mcp/cli/main.py

@@ -5,7 +5,7 @@ import json
 import sys
 from typing import Any, Callable, TextIO
 
-from ..errors import QingflowApiError
+from ..errors import QingflowApiError, backend_code_value_int, message_looks_like_invalid_token
 from ..public_surface import cli_public_tool_spec_from_namespace
 from ..response_trim import resolve_cli_tool_name, trim_error_response, trim_public_response
 from ..tools.ai_builder_tools import _attach_builder_apply_envelope
@@ -323,6 +323,8 @@ def _emit_error(payload: dict[str, Any], *, json_mode: bool, stdout: TextIO, std
         f"Category: {payload.get('category') or 'error'}",
         f"Message: {payload.get('message') or 'Unknown error'}",
     ]
+    if payload.get("error_code"):
+        lines.append(f"Error Code: {payload.get('error_code')}")
     if payload.get("backend_code") is not None:
         lines.append(f"Backend Code: {payload.get('backend_code')}")
     if payload.get("request_id"):
@@ -337,23 +339,65 @@ def _emit_error(payload: dict[str, Any], *, json_mode: bool, stdout: TextIO, std
 
 
 def _error_exit_code(payload: dict[str, Any]) -> int:
-    category = str(payload.get("category") or "").lower()
-    if category in {"auth", "workspace"}:
+    if _is_auth_or_workspace_payload(payload):
         return 3
     return 4
 
 
+def _is_auth_or_workspace_payload(payload: dict[str, Any]) -> bool:
+    category = str(payload.get("category") or "").lower()
+    error_code = str(payload.get("error_code") or "").upper()
+    http_status = backend_code_value_int(payload.get("http_status"))
+    if category in {"auth", "workspace"} or error_code in {"AUTH_REQUIRED", "WORKSPACE_NOT_SELECTED"}:
+        return True
+    if http_status == 401 or message_looks_like_invalid_token(payload.get("message")):
+        return True
+    return False
+
+
 def _result_exit_code(result: dict[str, Any]) -> int:
     if not isinstance(result, dict):
         return 0
+    if _is_executed_nonfatal_result(result):
+        return 0
+    if _is_auth_or_workspace_payload(result):
+        return 3
     if result.get("ok") is False:
         return 4
     status = str(result.get("status") or "").lower()
+    if status == "partial_success" and result.get("ok") is not True and not _has_readback_unavailable_verification(result):
+        return 4
     if status in {"failed", "blocked"}:
         return 4
     return 0
 
 
+def _is_executed_nonfatal_result(result: dict[str, Any]) -> bool:
+    status = str(result.get("status") or "").lower()
+    executed = bool(
+        result.get("write_executed")
+        or result.get("delete_executed")
+        or result.get("action_executed")
+        or result.get("export_executed")
+    )
+    return executed and status in {"partial_success", "verification_failed", "running", "queued", "unknown"}
+
+
+def _has_readback_unavailable_verification(result: dict[str, Any]) -> bool:
+    verification = result.get("verification")
+    if not isinstance(verification, dict):
+        return False
+    return any(
+        bool(verification.get(key))
+        for key in (
+            "readback_unavailable",
+            "readback_pending",
+            "metadata_unverified",
+            "views_read_unavailable",
+        )
+    )
+
+
 def _emit_cli_effective_context_notice(args: argparse.Namespace, context: CliContext, *, stream: TextIO) -> None:
     spec = cli_public_tool_spec_from_namespace(args)
     if spec is None or not spec.cli_show_effective_context:

package/src/qingflow_mcp/errors.py

@@ -9,11 +9,24 @@ from .json_types import JSONObject, JSONScalar
 INVALID_TOKEN_MARKERS = (
     "invalid token",
     "token invalid",
+    "token expired",
+    "expired token",
     "token失效",
     "无效token",
     "登录失效",
+    "登录过期",
+    "会话过期",
+    "session expired",
+    "session invalid",
     "login token invalid",
     "access token invalid",
+    "not logged in",
+    "not login",
+    "please login",
+    "please log in",
+    "未登录",
+    "请登录",
+    "重新登录",
 )
 
 
@@ -36,8 +49,7 @@ class QingflowApiError(Exception):
         return self.as_json()
 
     def looks_like_invalid_token(self) -> bool:
-        text = self.message.lower()
-        return any(marker in text for marker in INVALID_TOKEN_MARKERS)
+        return message_looks_like_invalid_token(self.message)
 
     @classmethod
     def auth_required(cls, profile: str) -> "QingflowApiError":
@@ -64,3 +76,32 @@ class QingflowApiError(Exception):
 
 def raise_tool_error(error: QingflowApiError) -> None:
     raise RuntimeError(error.as_json())
+
+
+def backend_code_value_int(code: JSONScalar) -> int | None:
+    if isinstance(code, bool) or code is None:
+        return None
+    if isinstance(code, int):
+        return code
+    if isinstance(code, str):
+        text = code.strip()
+        if text:
+            try:
+                return int(text)
+            except ValueError:
+                return None
+    return None
+
+
+def backend_code_int(error: QingflowApiError) -> int | None:
+    return backend_code_value_int(error.backend_code)
+
+
+def message_looks_like_invalid_token(message: object) -> bool:
+    text = str(message or "").lower()
+    return any(marker in text for marker in INVALID_TOKEN_MARKERS)
+
+
+def is_auth_like_error(error: QingflowApiError) -> bool:
+    category = str(error.category or "").strip().lower()
+    return category == "auth" or error.http_status == 401 or error.looks_like_invalid_token()