@josephyan/qingflow-cli 1.1.3 → 1.1.5

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
@@ -79,6 +79,23 @@ def run(
         return 2
     except SystemExit as exc:
         return int(exc.code or 0)
+    try:
+        _validate_conditional_args(args)
+    except _CliArgumentError as exc:
+        if _should_force_json_output_argv(normalized_argv):
+            payload = {
+                "category": "config",
+                "status": "failed",
+                "error_code": "ARGUMENT_ERROR",
+                "message": exc.message,
+                "details": {"usage": exc.usage.strip(), "prog": exc.prog},
+            }
+            payload = _maybe_attach_builder_apply_error_envelope_from_args(args, payload)
+            emit_json_result(payload, stream=out)
+            return 2
+        err.write(exc.usage)
+        err.write(f"{exc.prog}: error: {exc.message}\n")
+        return 2
     setattr(args, "_stdin", sys.stdin)
     setattr(args, "_stdout_stream", out)
     setattr(args, "_stderr_stream", err)
@@ -119,6 +136,50 @@ def run(
     return exit_code
 
 
+def _handle_version(_args: argparse.Namespace, _context: CliContext) -> dict[str, Any]:
+    info = get_cli_version_info()
+    return {
+        "ok": True,
+        "status": "success",
+        **info,
+    }
+
+
+def _emit_version(*, json_mode: bool, stdout: TextIO) -> int:
+    version = get_cli_version()
+    if json_mode:
+        emit_json_result(
+            {
+                "ok": True,
+                "status": "success",
+                **get_cli_version_info(),
+            },
+            stream=stdout,
+        )
+    else:
+        stdout.write(f"{version}\n")
+    return 0
+
+
+def _validate_conditional_args(args: argparse.Namespace) -> None:
+    if (
+        getattr(args, "command", "") in {"builder", "build"}
+        and getattr(args, "builder_command", "") == "layout"
+        and getattr(args, "builder_layout_command", "") == "apply"
+        and not getattr(args, "apps_file", None)
+        and not getattr(args, "sections_file", None)
+    ):
+        raise _CliArgumentError(
+            prog="qingflow builder layout apply",
+            message="--sections-file is required",
+            usage="usage: qingflow builder layout apply --app-key APP_KEY --sections-file SECTIONS.json\n",
+        )
+
+
+def _should_force_json_output_argv_for_version(argv: list[str]) -> bool:
+    return "--json" in argv
+
+
 def _normalize_global_args(argv: list[str]) -> list[str]:
     global_args: list[str] = []
     remaining: list[str] = []
@@ -150,35 +211,6 @@ def _normalize_global_args(argv: list[str]) -> list[str]:
     return global_args + remaining
 
 
-def _handle_version(_args: argparse.Namespace, _context: CliContext) -> dict[str, Any]:
-    info = get_cli_version_info()
-    return {
-        "ok": True,
-        "status": "success",
-        **info,
-    }
-
-
-def _emit_version(*, json_mode: bool, stdout: TextIO) -> int:
-    version = get_cli_version()
-    if json_mode:
-        emit_json_result(
-            {
-                "ok": True,
-                "status": "success",
-                **get_cli_version_info(),
-            },
-            stream=stdout,
-        )
-    else:
-        stdout.write(f"{version}\n")
-    return 0
-
-
-def _should_force_json_output_argv_for_version(argv: list[str]) -> bool:
-    return "--json" in argv
-
-
 def _should_force_json_output(args: argparse.Namespace) -> bool:
     if bool(getattr(args, "force_json_output", False)):
         return True
@@ -249,6 +281,8 @@ def _builder_apply_operation_from_args(args: argparse.Namespace) -> str | None:
         return "app_associated_resources_apply"
     if section == "portal" and getattr(args, "builder_portal_command", "") == "apply":
         return "portal_apply"
+    if section == "portal" and getattr(args, "builder_portal_command", "") == "delete":
+        return "portal_delete"
     if section == "schema" and getattr(args, "builder_schema_command", "") == "apply":
         return "app_schema_apply"
     if section == "layout" and getattr(args, "builder_layout_command", "") == "apply":
@@ -270,7 +304,7 @@ def _builder_apply_operation_from_argv(argv: list[str]) -> str | None:
         return None
     section = tokens[1]
     action = tokens[2]
-    if action != "apply" and not (section == "publish" and action == "verify"):
+    if action != "apply" and not (section == "publish" and action == "verify") and not (section == "portal" and action == "delete"):
         return None
     mapping = {
         "package": "package_apply",
@@ -285,6 +319,8 @@ def _builder_apply_operation_from_argv(argv: list[str]) -> str | None:
         "charts": "app_charts_apply",
         "publish": "app_publish_verify",
     }
+    if section == "portal" and action == "delete":
+        return "portal_delete"
     return mapping.get(section)
 
 
@@ -364,6 +400,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"):
@@ -378,23 +416,69 @@ 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 str(payload.get("error_code") or "").upper() == "ARGUMENT_ERROR":
+        return 2
+    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("write_may_have_succeeded")
+        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",
+            "readback_before_retry",
+        )
+    )
+
+
 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()

package/src/qingflow_mcp/public_surface.py

@@ -51,35 +51,40 @@ USER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
         "record_schema_get",
         cli_route=("record", "schema", "applicant"),
         mcp_public=False,
+        cli_public=False,
     ),
     PublicToolSpec(
         USER_DOMAIN,
         "record_browse_schema_get",
         ("record_browse_schema_get_public",),
         ("record", "schema", "browse"),
+        cli_show_effective_context=True,
     ),
     PublicToolSpec(
         USER_DOMAIN,
         "record_insert_schema_get",
         ("record_insert_schema_get_public",),
         ("record", "schema", "insert"),
+        cli_show_effective_context=True,
     ),
     PublicToolSpec(
         USER_DOMAIN,
         "record_update_schema_get",
         ("record_update_schema_get_public",),
         ("record", "schema", "update"),
+        cli_show_effective_context=True,
     ),
-    PublicToolSpec(USER_DOMAIN, "record_import_schema_get", ("record_import_schema_get",), ("record", "schema", "import")),
+    PublicToolSpec(USER_DOMAIN, "record_import_schema_get", ("record_import_schema_get",), ("record", "schema", "import"), cli_show_effective_context=True),
     PublicToolSpec(
         USER_DOMAIN,
         "record_code_block_schema_get",
         ("record_code_block_schema_get_public",),
         ("record", "schema", "code-block"),
+        cli_show_effective_context=True,
     ),
-    PublicToolSpec(USER_DOMAIN, "record_member_candidates", ("record_member_candidates",), ("record", "member-candidates")),
-    PublicToolSpec(USER_DOMAIN, "record_department_candidates", ("record_department_candidates",), ("record", "department-candidates")),
-    PublicToolSpec(USER_DOMAIN, "record_analyze", ("record_analyze",), ("record", "analyze"), mcp_public=False),
+    PublicToolSpec(USER_DOMAIN, "record_member_candidates", ("record_member_candidates",), ("record", "member-candidates"), cli_show_effective_context=True),
+    PublicToolSpec(USER_DOMAIN, "record_department_candidates", ("record_department_candidates",), ("record", "department-candidates"), cli_show_effective_context=True),
+    PublicToolSpec(USER_DOMAIN, "record_analyze", ("record_analyze",), ("record", "analyze"), mcp_public=False, cli_public=False),
     PublicToolSpec(USER_DOMAIN, "record_list", ("record_list",), ("record", "list"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "record_access", ("record_access",), ("record", "access"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "record_get", ("record_get_public",), ("record", "get"), cli_show_effective_context=True),
@@ -87,11 +92,11 @@ USER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(USER_DOMAIN, "record_insert", ("record_insert_public",), ("record", "insert"), cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(USER_DOMAIN, "record_update", ("record_update_public",), ("record", "update"), cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(USER_DOMAIN, "record_delete", ("record_delete_public",), ("record", "delete"), cli_show_effective_context=True, cli_context_write=True),
-    PublicToolSpec(USER_DOMAIN, "record_import_template_get", ("record_import_template_get",), ("import", "template")),
-    PublicToolSpec(USER_DOMAIN, "record_import_verify", ("record_import_verify",), ("import", "verify")),
+    PublicToolSpec(USER_DOMAIN, "record_import_template_get", ("record_import_template_get",), ("import", "template"), cli_show_effective_context=True),
+    PublicToolSpec(USER_DOMAIN, "record_import_verify", ("record_import_verify",), ("import", "verify"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "record_import_repair_local", ("record_import_repair_local",), ("import", "repair")),
-    PublicToolSpec(USER_DOMAIN, "record_import_start", ("record_import_start",), ("import", "start")),
-    PublicToolSpec(USER_DOMAIN, "record_import_status_get", ("record_import_status_get",), ("import", "status")),
+    PublicToolSpec(USER_DOMAIN, "record_import_start", ("record_import_start",), ("import", "start"), cli_show_effective_context=True, cli_context_write=True),
+    PublicToolSpec(USER_DOMAIN, "record_import_status_get", ("record_import_status_get",), ("import", "status"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "record_export_start", ("record_export_start",), ("export", "start"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "record_export_status_get", ("record_export_status_get",), ("export", "status"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "record_export_get", ("record_export_get",), ("export", "get"), cli_show_effective_context=True),
@@ -109,12 +114,12 @@ USER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     ),
     PublicToolSpec(USER_DOMAIN, "task_workflow_log_get", ("task_workflow_log_get",), ("task", "log"), cli_show_effective_context=True),
     PublicToolSpec(USER_DOMAIN, "directory_search", ("directory_search",), cli_public=False),
-    PublicToolSpec(USER_DOMAIN, "directory_list_internal_users", ("directory_list_internal_users",), cli_public=False),
-    PublicToolSpec(USER_DOMAIN, "directory_list_all_internal_users", ("directory_list_all_internal_users",), cli_public=False),
-    PublicToolSpec(USER_DOMAIN, "directory_list_internal_departments", ("directory_list_internal_departments",), cli_public=False),
-    PublicToolSpec(USER_DOMAIN, "directory_list_all_departments", ("directory_list_all_departments",), cli_public=False),
-    PublicToolSpec(USER_DOMAIN, "directory_list_sub_departments", ("directory_list_sub_departments",), cli_public=False),
-    PublicToolSpec(USER_DOMAIN, "directory_list_external_members", ("directory_list_external_members",), cli_public=False),
+    PublicToolSpec(USER_DOMAIN, "directory_list_internal_users", ("directory_list_internal_users",), mcp_public=False, cli_public=False),
+    PublicToolSpec(USER_DOMAIN, "directory_list_all_internal_users", ("directory_list_all_internal_users",), mcp_public=False, cli_public=False),
+    PublicToolSpec(USER_DOMAIN, "directory_list_internal_departments", ("directory_list_internal_departments",), mcp_public=False, cli_public=False),
+    PublicToolSpec(USER_DOMAIN, "directory_list_all_departments", ("directory_list_all_departments",), mcp_public=False, cli_public=False),
+    PublicToolSpec(USER_DOMAIN, "directory_list_sub_departments", ("directory_list_sub_departments",), mcp_public=False, cli_public=False),
+    PublicToolSpec(USER_DOMAIN, "directory_list_external_members", ("directory_list_external_members",), mcp_public=False, cli_public=False),
 )
 
 
@@ -138,9 +143,7 @@ BUILDER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(BUILDER_DOMAIN, "app_release_edit_lock_if_mine", ("app_release_edit_lock_if_mine",), ("builder", "app", "release-edit-lock-if-mine"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_resolve", ("app_resolve",), ("builder", "app", "resolve"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "button_style_catalog_get", ("button_style_catalog_get",), ("builder", "button", "catalog"), has_contract=True, cli_show_effective_context=True),
-    PublicToolSpec(BUILDER_DOMAIN, "app_get_buttons", ("app_get_buttons",), ("builder", "button", "get"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_custom_buttons_apply", ("app_custom_buttons_apply",), ("builder", "button", "apply"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
-    PublicToolSpec(BUILDER_DOMAIN, "app_get_associated_resources", ("app_get_associated_resources",), ("builder", "associated-resource", "get"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_associated_resources_apply", ("app_associated_resources_apply",), ("builder", "associated-resource", "apply"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_get", ("app_get",), ("builder", "app", "get", "summary"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_get_fields", ("app_get_fields",), ("builder", "app", "get", "fields"), has_contract=True, cli_show_effective_context=True),
@@ -149,6 +152,10 @@ BUILDER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(BUILDER_DOMAIN, "app_get_views", ("app_get_views",), ("builder", "app", "get", "views"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_get_flow", ("app_get_flow",), ("builder", "app", "get", "flow"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_get_charts", ("app_get_charts",), ("builder", "app", "get", "charts"), has_contract=True, cli_show_effective_context=True),
+    PublicToolSpec(BUILDER_DOMAIN, "app_get_buttons", ("app_get_buttons",), ("builder", "app", "get", "buttons"), has_contract=True, cli_show_effective_context=True),
+    PublicToolSpec(BUILDER_DOMAIN, "app_get_associated_resources", ("app_get_associated_resources",), ("builder", "app", "get", "associated-resources"), has_contract=True, cli_show_effective_context=True),
+    PublicToolSpec(BUILDER_DOMAIN, "app_get_buttons", ("app_get_buttons",), ("builder", "button", "get"), has_contract=True, cli_show_effective_context=True),
+    PublicToolSpec(BUILDER_DOMAIN, "app_get_associated_resources", ("app_get_associated_resources",), ("builder", "associated-resource", "get"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "portal_list", ("portal_list",), ("builder", "portal", "list"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "portal_get", ("portal_get",), ("builder", "portal", "get"), has_contract=True, cli_show_effective_context=True),
     PublicToolSpec(BUILDER_DOMAIN, "view_get", ("view_get",), ("builder", "view", "get"), has_contract=True, cli_show_effective_context=True),
@@ -161,7 +168,8 @@ BUILDER_PUBLIC_TOOL_SPECS: tuple[PublicToolSpec, ...] = (
     PublicToolSpec(BUILDER_DOMAIN, "app_views_apply", ("app_views_apply",), ("builder", "views", "apply"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(BUILDER_DOMAIN, "app_charts_apply", ("app_charts_apply",), ("builder", "charts", "apply"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
     PublicToolSpec(BUILDER_DOMAIN, "portal_apply", ("portal_apply",), ("builder", "portal", "apply"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
-    PublicToolSpec(BUILDER_DOMAIN, "app_publish_verify", ("app_publish_verify",), ("builder", "publish", "verify"), has_contract=True, cli_show_effective_context=True),
+    PublicToolSpec(BUILDER_DOMAIN, "portal_delete", ("portal_delete",), ("builder", "portal", "delete"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
+    PublicToolSpec(BUILDER_DOMAIN, "app_publish_verify", ("app_publish_verify",), ("builder", "publish", "verify"), has_contract=True, cli_show_effective_context=True, cli_context_write=True),
 )
 
 
@@ -239,6 +247,7 @@ def cli_route_from_namespace(args: Namespace) -> tuple[str, ...] | None:
     builder_command = getattr(args, "builder_command", None)
     if not isinstance(builder_command, str) or not builder_command:
         return None
+    builder_command = "associated-resource" if builder_command == "associated-resources" else builder_command
     if builder_command == "contract":
         return ("builder", "contract")
     if builder_command == "app":

package/src/qingflow_mcp/response_trim.py

@@ -47,7 +47,6 @@ COMMON_ERROR_DROP_TOP = {
     "allowed_values",
     "missing_fields",
     "noop",
-    "ok",
 }
 
 SUCCESS_POLICY_BY_TOOL: dict[str, TransformFn] = {}
@@ -58,11 +57,18 @@ def trim_public_response(tool_name: str | None, payload: dict[str, Any]) -> dict
         return payload
     if _looks_like_failure_payload(payload):
         status = str(payload.get("status") or "").lower()
-        if tool_name in {"user:record_insert", "user:record_update", "user:record_delete"} and status in {
-            "blocked",
-            "needs_confirmation",
-            "partial_success",
-        }:
+        if _is_executed_nonfatal_payload(payload) or (
+            tool_name in {"user:record_insert", "user:record_update", "user:record_delete"}
+            and status in {
+                "blocked",
+                "needs_confirmation",
+                "partial_success",
+            }
+        ) or (
+            tool_name == "user:record_import_verify"
+            and status == "failed"
+            and "can_import" in payload
+        ):
             return trim_success_response(tool_name, payload)
         return _trim_returned_failure(payload)
     return trim_success_response(tool_name, payload)
@@ -94,7 +100,7 @@ def trim_error_response(payload: dict[str, Any]) -> dict[str, Any]:
     details = trimmed.get("details")
     if isinstance(details, dict):
         preserved = {}
-        for key in ("blocking_issues", "compiled_match_rules"):
+        for key in ("blocking_issues", "compiled_match_rules", "issues", "expected_shape"):
             if key in details:
                 preserved[key] = details.get(key)
         compact_details = _compact_scalar_dict(details)
@@ -151,12 +157,26 @@ def _parse_runtime_error_payload(exc: RuntimeError) -> dict[str, Any] | None:
 
 
 def _looks_like_failure_payload(payload: dict[str, Any]) -> bool:
+    if _is_executed_nonfatal_payload(payload):
+        return False
     if payload.get("ok") is False:
         return True
     status = str(payload.get("status") or "").lower()
     return status in {"failed", "blocked"}
 
 
+def _is_executed_nonfatal_payload(payload: dict[str, Any]) -> bool:
+    status = str(payload.get("status") or "").lower()
+    executed = bool(
+        payload.get("write_executed")
+        or payload.get("write_may_have_succeeded")
+        or payload.get("delete_executed")
+        or payload.get("action_executed")
+        or payload.get("export_executed")
+    )
+    return executed and status in {"partial_success", "verification_failed", "running", "queued", "unknown"}
+
+
 def _trim_returned_failure(payload: dict[str, Any]) -> dict[str, Any]:
     trimmed = deepcopy(payload)
     _drop_top_keys(trimmed, COMMON_ERROR_DROP_TOP)
@@ -164,7 +184,7 @@ def _trim_returned_failure(payload: dict[str, Any]) -> dict[str, Any]:
     details = trimmed.get("details")
     if isinstance(details, dict):
         preserved = {}
-        for key in ("blocking_issues", "compiled_match_rules"):
+        for key in ("blocking_issues", "compiled_match_rules", "issues", "expected_shape"):
             if key in details:
                 preserved[key] = details.get(key)
         compact_details = _compact_scalar_dict(details)
@@ -325,15 +345,22 @@ def _trim_import_schema(payload: JSONObject) -> None:
         columns = [item for item in payload.get("expected_columns", []) if isinstance(item, dict)]
     if columns is not None:
         payload["columns"] = [_compact_import_column(item) for item in columns]
+    import_capability = payload.get("import_capability") if isinstance(payload.get("import_capability"), dict) else {}
+    if import_capability:
+        verification = payload.get("verification") if isinstance(payload.get("verification"), dict) else {}
+        if not isinstance(payload.get("verification"), dict):
+            payload["verification"] = verification
+        verification.setdefault("import_auth_source", import_capability.get("auth_source"))
+        verification.setdefault("import_capability_can_import", import_capability.get("can_import"))
     payload.pop("expected_columns", None)
     payload.pop("schema_fingerprint", None)
     payload.pop("import_capability", None)
     payload.pop("request_route", None)
-    payload.pop("verification", None)
 
     if _looks_like_import_verify(payload):
         _trim_import_verify_payload(payload)
         return
+    payload.pop("verification", None)
     if "applied_repairs" in payload or "repaired_file_path" in payload:
         _trim_import_repair_payload(payload)
         return
@@ -394,10 +421,14 @@ def _trim_record_write(payload: JSONObject) -> None:
     data.pop("normalized_payload", None)
     data.pop("human_review", None)
     data.pop("action", None)
-    for key in ("update_route", "tried_routes"):
-        value = payload.get(key)
-        if value not in (None, [], {}, ""):
-            data[key] = value
+    if payload.get("status") == "success":
+        data.pop("tried_routes", None)
+    update_route = payload.get("update_route")
+    if update_route not in (None, [], {}, ""):
+        data["update_route"] = update_route
+    tried_routes = payload.get("tried_routes")
+    if payload.get("status") != "success" and tried_routes not in (None, [], {}, ""):
+        data["tried_routes"] = tried_routes
     resource = _compact_record_resource(data.get("resource"))
     if resource:
         data["resource"] = resource
@@ -441,6 +472,7 @@ def _trim_record_write_batch(payload: JSONObject, data: JSONObject) -> None:
                     "record_id",
                     "apply_id",
                     "write_executed",
+                    "write_succeeded",
                     "verification_status",
                     "safe_to_retry",
                     "update_route",
@@ -887,6 +919,12 @@ def _compact_import_column(item: dict[str, Any]) -> dict[str, Any]:
         compact["options"] = options
     if bool(item.get("accepts_natural_input")):
         compact["accepts_natural_input"] = True
+    import_value_format = item.get("import_value_format")
+    if isinstance(import_value_format, str) and import_value_format:
+        compact["import_value_format"] = import_value_format
+    format_hint = item.get("format_hint")
+    if isinstance(format_hint, str) and format_hint:
+        compact["format_hint"] = format_hint
     if bool(item.get("requires_upload")):
         compact["requires_upload"] = True
     target_app_key = item.get("target_app_key")
@@ -902,13 +940,37 @@ def _compact_import_column(item: dict[str, Any]) -> dict[str, Any]:
 
 
 def _looks_like_import_verify(payload: JSONObject) -> bool:
-    return "verification_id" in payload and "can_import" in payload
+    if "verification_id" in payload and "can_import" in payload:
+        return True
+    return "can_import" in payload and (
+        "error_code" in payload
+        or "issues" in payload
+        or "file_path" in payload
+    )
 
 
 def _trim_import_verify_payload(payload: JSONObject) -> None:
     issues = payload.get("issues") if isinstance(payload.get("issues"), list) else []
     issue_summary = _summarize_import_issues(issues)
     payload["issue_summary"] = issue_summary
+    verification = payload.get("verification") if isinstance(payload.get("verification"), dict) else {}
+    compact_verification = {
+        key: verification.get(key)
+        for key in (
+            "import_auth_prechecked",
+            "import_auth_precheck_passed",
+            "import_auth_source",
+            "import_capability_can_import",
+            "local_precheck_passed",
+            "backend_verification_passed",
+            "auto_normalized",
+        )
+        if key in verification
+    }
+    if compact_verification:
+        payload["verification"] = compact_verification
+    else:
+        payload.pop("verification", None)
     columns = payload.get("columns")
     if "expected_columns" not in payload and isinstance(columns, list):
         payload["expected_columns"] = columns
@@ -1004,13 +1066,14 @@ def _trim_feedback(payload: JSONObject) -> None:
 
 
 def _trim_builder_envelope(payload: JSONObject) -> None:
-    if str(payload.get("status") or "").lower() == "success":
+    if str(payload.get("status") or "").lower() in {"success", "partial_success", "verification_failed"}:
         details = payload.get("details")
         if isinstance(details, dict):
             _drop_deep_keys(details, {"request_route", "base_url", "normalized_args", "suggested_next_call", "transport", "response", "body", "raw"})
             preserved = {}
-            if isinstance(details.get("compiled_match_rules"), dict):
-                preserved["compiled_match_rules"] = details.get("compiled_match_rules")
+            for key in ("compiled_match_rules", "issues", "expected_shape"):
+                if key in details:
+                    preserved[key] = details.get(key)
             compact = _compact_scalar_dict(details)
             compact.update(preserved)
             if compact:
@@ -1142,6 +1205,7 @@ _register_policy(
         "app_views_apply",
         "app_charts_apply",
         "portal_apply",
+        "portal_delete",
         "app_publish_verify",
     ),
     _trim_builder_list_like,